readme

added structs example

.gitignore

@@ -24,8 +24,6 @@ __pycache__/
 parser.out
 parsetab.py
 .pytest_cache/
-compiler/src/prog8_kotlin.jar
-compiler/src/compiled_java
 .attach_pid*
 
 .gradle

.idea/.gitignore

@@ -0,0 +1,2 @@
+# Default ignored files
+/shelf/

.idea/dictionaries/irmen.xml

@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="irmen" />
+</component>

.idea/gradle.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleHome" value="/usr/share/java/gradle" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/compiler" />
-            <option value="$PROJECT_DIR$/parser" />
-          </set>
-        </option>
-        <option name="useQualifiedModuleNames" value="true" />
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,10 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="SpellCheckingInspection" enabled="true" level="TYPO" enabled_by_default="true">
+      <option name="processCode" value="false" />
+      <option name="processLiterals" value="true" />
+      <option name="processComments" value="false" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/kotlinc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="1.8" />
+  </component>
+</project>

.idea/libraries/KotlinJavaRuntime.xml

@@ -0,0 +1,19 @@
+<component name="libraryTable">
+  <library name="KotlinJavaRuntime">
+    <CLASSES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

.idea/libraries/antlr_4_7_2_complete.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="antlr-4.7.2-complete">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-4.7.2-complete.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/antlr_runtime_4_7_2.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="antlr-runtime-4.7.2">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/parser/antlr/lib/antlr-runtime-4.7.2.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/unittest_libs.xml

@@ -0,0 +1,10 @@
+<component name="libraryTable">
+  <library name="unittest-libs">
+    <CLASSES>
+      <root url="file://$PROJECT_DIR$/compiler/lib" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+    <jarDirectory url="file://$PROJECT_DIR$/compiler/lib" recursive="false" />
+  </library>
+</component>

.idea/misc.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -2,7 +2,11 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/DeprecatedStackVm/DeprecatedStackVm.iml" filepath="$PROJECT_DIR$/DeprecatedStackVm/DeprecatedStackVm.iml" />
+      <module fileurl="file://$PROJECT_DIR$/compiler/compiler.iml" filepath="$PROJECT_DIR$/compiler/compiler.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$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
     </modules>
   </component>
 </project>

.idea/uiDesigner.xml

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Palette2">
+    <group name="Swing">
+      <item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
+      </item>
+      <item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.png" removable="false" auto-create-binding="false" can-attach-label="true">
+        <default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
+        <initial-values>
+          <property name="text" value="Button" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="RadioButton" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="CheckBox" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="Label" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
+          <preferred-size width="-1" height="20" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
+      </item>
+    </group>
+  </component>
+</project>

.idea/vcs.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
 </project>

.travis.yml

@@ -0,0 +1,11 @@
+language: java
+# jdk: openjdk8
+# dist: xenial
+# sudo: false
+
+before_install:
+  - chmod +x gradlew
+
+script:
+  - ./gradlew test
+

DeprecatedStackVm/DeprecatedStackVm.iml

@@ -0,0 +1,10 @@
+<?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$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+  </component>
+</module>

DeprecatedStackVm/src/compiler/intermediate/Instruction.kt

@@ -1,10 +1,11 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
-import prog8.stackvm.Syscall
+import prog8.vm.RuntimeValue
+import prog8.vm.stackvm.Syscall
 
 open class Instruction(val opcode: Opcode,
-                       val arg: Value? = null,
-                       val arg2: Value? = null,
+                       val arg: RuntimeValue? = null,
+                       val arg2: RuntimeValue? = null,
                        val callLabel: String? = null,
                        val callLabel2: String? = null)
 {
@@ -14,8 +15,8 @@ open class Instruction(val opcode: Opcode,
         val argStr = arg?.toString() ?: ""
         val result =
                 when {
-                    opcode==Opcode.LINE -> "_line  $callLabel"
-                    opcode==Opcode.INLINE_ASSEMBLY -> {
+                    opcode== Opcode.LINE -> "_line  $callLabel"
+                    opcode== Opcode.INLINE_ASSEMBLY -> {
                         // inline assembly is not written out (it can't be processed as intermediate language)
                         // instead, it is converted into a system call that can be intercepted by the vm
                         if(callLabel!=null)
@@ -23,10 +24,10 @@ open class Instruction(val opcode: Opcode,
                         else
                             "inline_assembly"
                     }
-                    opcode==Opcode.INCLUDE_FILE -> {
+                    opcode== Opcode.INCLUDE_FILE -> {
                         "include_file \"$callLabel\" $arg $arg2"
                     }
-                    opcode==Opcode.SYSCALL -> {
+                    opcode== Opcode.SYSCALL -> {
                         val syscall = Syscall.values().find { it.callNr==arg!!.numericValue() }
                         "syscall  $syscall"
                     }

DeprecatedStackVm/src/compiler/intermediate/IntermediateProgram.kt

@@ -1,53 +1,53 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
-import prog8.ast.*
+import prog8.ast.antlr.escape
+import prog8.ast.base.*
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.VarDecl
+import prog8.ast.statements.ZeropageWish
 import prog8.compiler.CompilerException
 import prog8.compiler.HeapValues
 import prog8.compiler.Zeropage
 import prog8.compiler.ZeropageDepletedError
+import prog8.vm.RuntimeValue
 import java.io.PrintStream
 import java.nio.file.Path
 
 
-class IntermediateProgram(val name: String, var loadAddress: Int, val heap: HeapValues, val importedFrom: Path) {
+class IntermediateProgram(val name: String, var loadAddress: Int, val heap: HeapValues, val source: Path) {
+
+    class VariableParameters (val zp: ZeropageWish, val memberOfStruct: StructDecl?)
+    class Variable(val scopedname: String, val value: RuntimeValue, val params: VariableParameters)
 
     class ProgramBlock(val name: String,
                        var address: Int?,
                        val instructions: MutableList<Instruction> = mutableListOf(),
-                       val variables: MutableMap<String, Value> = mutableMapOf(),           // names are fully scoped
+                       val variables: MutableList<Variable> = mutableListOf(),
                        val memoryPointers: MutableMap<String, Pair<Int, DataType>> = mutableMapOf(),
                        val labels: MutableMap<String, Instruction> = mutableMapOf(),        // names are fully scoped
                        val force_output: Boolean)
-    {
-        val numVariables: Int
-            get() { return variables.size }
-        val numInstructions: Int
-            get() { return instructions.filter { it.opcode!= Opcode.LINE }.size }
-        val variablesMarkedForZeropage: MutableSet<String> = mutableSetOf()
-    }
 
     val allocatedZeropageVariables = mutableMapOf<String, Pair<Int, DataType>>()
     val blocks = mutableListOf<ProgramBlock>()
-    val memory = mutableMapOf<Int, List<Value>>()
+    val memory = mutableMapOf<Int, List<RuntimeValue>>()
     private lateinit var currentBlock: ProgramBlock
 
-    val numVariables: Int
-        get() = blocks.sumBy { it.numVariables }
-    val numInstructions: Int
-        get() = blocks.sumBy { it.numInstructions }
-
-    fun allocateZeropage(zeropage: Zeropage) {
+    fun allocateZeropage(zeropage: Zeropage) {          // TODO not used anymore???
         // allocates all @zp marked variables on the zeropage (for all blocks, as long as there is space in the ZP)
         var notAllocated = 0
         for(block in blocks) {
-            val zpVariables = block.variables.filter { it.key in block.variablesMarkedForZeropage }
+            val zpVariables = block.variables.filter { it.params.zp==ZeropageWish.REQUIRE_ZEROPAGE || it.params.zp==ZeropageWish.PREFER_ZEROPAGE }
             if (zpVariables.isNotEmpty()) {
                 for (variable in zpVariables) {
+                    if(variable.params.zp==ZeropageWish.NOT_IN_ZEROPAGE || variable.params.memberOfStruct!=null)
+                        throw CompilerException("zp conflict")
                     try {
-                        val address = zeropage.allocate(variable.key, variable.value.type, null)
-                        allocatedZeropageVariables[variable.key] = Pair(address, variable.value.type)
+                        val address = zeropage.allocate(variable.scopedname, variable.value.type, null)
+                        allocatedZeropageVariables[variable.scopedname] = Pair(address, variable.value.type)
                     } catch (x: ZeropageDepletedError) {
-                        printWarning(x.toString() + " variable ${variable.key} type ${variable.value.type}")
+                        printWarning(x.toString() + " variable ${variable.scopedname} type ${variable.value.type}")
                         notAllocated++
                     }
                 }
@@ -85,10 +85,10 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
         val branchOpcodes = setOf(Opcode.JZ, Opcode.JNZ, Opcode.JZW, Opcode.JNZW)
         for(blk in blocks) {
             val instructionsToReplace = mutableMapOf<Int, Instruction>()
-            blk.instructions.asSequence().withIndex().filter {it.value.opcode!=Opcode.LINE}.windowed(2).toList().forEach {
+            blk.instructions.asSequence().withIndex().filter {it.value.opcode!= Opcode.LINE }.windowed(2).toList().forEach {
                 if (it[1].value.opcode in branchOpcodes) {
                     if (it[0].value.opcode in pushvalue) {
-                        val value = it[0].value.arg!!.asBooleanValue
+                        val value = it[0].value.arg!!.asBoolean
                         instructionsToReplace[it[0].index] = Instruction(Opcode.NOP)
                         val replacement: Instruction =
                                 if (value) {
@@ -138,8 +138,8 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
         for(blk in blocks) {
             val instructionsToReplace = mutableMapOf<Int, Instruction>()
 
-            blk.instructions.asSequence().withIndex().filter {it.value.opcode!=Opcode.LINE}.windowed(2).toList().forEach {
-                if(it[0].value.opcode==Opcode.CALL && it[1].value.opcode==Opcode.RETURN) {
+            blk.instructions.asSequence().withIndex().filter {it.value.opcode!= Opcode.LINE }.windowed(2).toList().forEach {
+                if(it[0].value.opcode== Opcode.CALL && it[1].value.opcode== Opcode.RETURN) {
                     instructionsToReplace[it[1].index] = Instruction(Opcode.JUMP, callLabel = it[0].value.callLabel)
                     instructionsToReplace[it[0].index] = Instruction(Opcode.NOP)
                 }
@@ -256,17 +256,17 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
                 Opcode.CAST_W_TO_UB, Opcode.CAST_UW_TO_UB -> {
-                    val ins = Instruction(Opcode.PUSH_BYTE, Value(DataType.UBYTE, ins0.arg!!.integerValue() and 255))
+                    val ins = Instruction(Opcode.PUSH_BYTE, RuntimeValue(DataType.UBYTE, ins0.arg!!.integerValue() and 255))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
                 Opcode.MSB -> {
-                    val ins = Instruction(Opcode.PUSH_BYTE, Value(DataType.UBYTE, ins0.arg!!.integerValue() ushr 8 and 255))
+                    val ins = Instruction(Opcode.PUSH_BYTE, RuntimeValue(DataType.UBYTE, ins0.arg!!.integerValue() ushr 8 and 255))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
                 Opcode.CAST_W_TO_F, Opcode.CAST_UW_TO_F -> {
-                    val ins = Instruction(Opcode.PUSH_FLOAT, Value(DataType.FLOAT, ins0.arg!!.integerValue().toDouble()))
+                    val ins = Instruction(Opcode.PUSH_FLOAT, RuntimeValue(DataType.FLOAT, ins0.arg!!.integerValue().toDouble()))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
@@ -296,12 +296,12 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
                 Opcode.CAST_UW_TO_B, Opcode.CAST_UW_TO_UB -> instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 Opcode.MSB -> throw CompilerException("msb of a byte")
                 Opcode.CAST_UB_TO_UW -> {
-                    val ins = Instruction(Opcode.PUSH_WORD, Value(DataType.UWORD, ins0.arg!!.integerValue()))
+                    val ins = Instruction(Opcode.PUSH_WORD, RuntimeValue(DataType.UWORD, ins0.arg!!.integerValue()))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
                 Opcode.CAST_B_TO_W -> {
-                    val ins = Instruction(Opcode.PUSH_WORD, Value(DataType.WORD, ins0.arg!!.integerValue()))
+                    val ins = Instruction(Opcode.PUSH_WORD, RuntimeValue(DataType.WORD, ins0.arg!!.integerValue()))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
@@ -315,17 +315,18 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
-                Opcode.CAST_B_TO_F, Opcode.CAST_UB_TO_F-> {
-                    val ins = Instruction(Opcode.PUSH_FLOAT, Value(DataType.FLOAT, ins0.arg!!.integerValue().toDouble()))
+                Opcode.CAST_B_TO_F, Opcode.CAST_UB_TO_F -> {
+                    val ins = Instruction(Opcode.PUSH_FLOAT, RuntimeValue(DataType.FLOAT, ins0.arg!!.integerValue().toDouble()))
                     instructionsToReplace[index0] = ins
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
-                Opcode.CAST_W_TO_F, Opcode.CAST_UW_TO_F-> throw CompilerException("invalid conversion following a byte")
+                Opcode.CAST_W_TO_F, Opcode.CAST_UW_TO_F -> throw CompilerException("invalid conversion following a byte")
                 Opcode.DISCARD_BYTE -> {
                     instructionsToReplace[index0] = Instruction(Opcode.NOP)
                     instructionsToReplace[index1] = Instruction(Opcode.NOP)
                 }
                 Opcode.DISCARD_WORD, Opcode.DISCARD_FLOAT -> throw CompilerException("invalid discard type following a byte")
+                Opcode.MKWORD -> {}
                 else -> throw CompilerException("invalid conversion opcode ${ins1.opcode}")
             }
         }
@@ -387,44 +388,58 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
     fun variable(scopedname: String, decl: VarDecl) {
         when(decl.type) {
             VarDeclType.VAR -> {
+                // var decls that are defined inside of a StructDecl are skipped in the output
+                //   because every occurrence of the members will have a separate mangled vardecl for that occurrence
+                if(decl.parent is StructDecl)
+                    return
+
+                val valueparams = VariableParameters(decl.zeropage, decl.struct)
                 val value = when(decl.datatype) {
-                    in NumericDatatypes -> Value(decl.datatype, (decl.value as LiteralValue).asNumericValue!!)
+                    in NumericDatatypes -> {
+                        RuntimeValue(decl.datatype, (decl.value as NumericLiteralValue).number)
+                    }
                     in StringDatatypes -> {
-                        val litval = (decl.value as LiteralValue)
+                        val litval = (decl.value as ReferenceLiteralValue)
                         if(litval.heapId==null)
                             throw CompilerException("string should already be in the heap")
-                        Value(decl.datatype, litval.heapId)
+                        RuntimeValue(decl.datatype, heapId = litval.heapId)
                     }
                     in ArrayDatatypes -> {
-                        val litval = (decl.value as LiteralValue)
-                        if(litval.heapId==null)
+                        val litval = (decl.value as? ReferenceLiteralValue)
+                        if(litval!=null && litval.heapId==null)
                             throw CompilerException("array should already be in the heap")
-                        Value(decl.datatype, litval.heapId)
+                        if(litval!=null){
+                            RuntimeValue(decl.datatype, heapId = litval.heapId)
+                        } else {
+                            throw CompilerException("initialization value expected")
+                        }
+                    }
+                    DataType.STRUCT -> {
+                        // struct variables have been flattened already
+                        return
                     }
                     else -> throw CompilerException("weird datatype")
                 }
-                currentBlock.variables[scopedname] = value
-                if(decl.zeropage)
-                    currentBlock.variablesMarkedForZeropage.add(scopedname)
+                currentBlock.variables.add(Variable(scopedname, value, valueparams))
             }
             VarDeclType.MEMORY -> {
                 // note that constants are all folded away, but assembly code may still refer to them
-                val lv = decl.value as LiteralValue
-                if(lv.type!=DataType.UWORD && lv.type!=DataType.UBYTE)
+                val lv = decl.value as NumericLiteralValue
+                if(lv.type!= DataType.UWORD && lv.type!= DataType.UBYTE)
                     throw CompilerException("expected integer memory address $lv")
-                currentBlock.memoryPointers[scopedname] = Pair(lv.asIntegerValue!!, decl.datatype)
+                currentBlock.memoryPointers[scopedname] = Pair(lv.number.toInt(), decl.datatype)
             }
             VarDeclType.CONST -> {
                 // note that constants are all folded away, but assembly code may still refer to them (if their integers)
                 // floating point constants are not generated at all!!
-                val lv = decl.value as LiteralValue
+                val lv = decl.value as NumericLiteralValue
                 if(lv.type in IntegerDatatypes)
-                    currentBlock.memoryPointers[scopedname] = Pair(lv.asIntegerValue!!, decl.datatype)
+                    currentBlock.memoryPointers[scopedname] = Pair(lv.number.toInt(), decl.datatype)
             }
         }
     }
 
-    fun instr(opcode: Opcode, arg: Value? = null, arg2: Value? = null, callLabel: String? = null, callLabel2: String? = null) {
+    fun instr(opcode: Opcode, arg: RuntimeValue? = null, arg2: RuntimeValue? = null, callLabel: String? = null, callLabel2: String? = null) {
         currentBlock.instructions.add(Instruction(opcode, arg, arg2, callLabel, callLabel2))
     }
 
@@ -447,16 +462,20 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
     }
 
     fun newBlock(name: String, address: Int?, options: Set<String>) {
-        currentBlock = ProgramBlock(name, address, force_output="force_output" in options)
+        currentBlock = ProgramBlock(name, address, force_output = "force_output" in options)
         blocks.add(currentBlock)
     }
 
     fun writeCode(out: PrintStream, embeddedLabels: Boolean=true) {
         out.println("; stackVM program code for '$name'")
-        out.println("%memory")
-        if(memory.isNotEmpty())
-            TODO("add support for writing/reading initial memory values")
-        out.println("%end_memory")
+        writeMemory(out)
+        writeHeap(out)
+        for(blk in blocks) {
+            writeBlock(out, blk, embeddedLabels)
+        }
+    }
+
+    private fun writeHeap(out: PrintStream) {
         out.println("%heap")
         heap.allEntries().forEach {
             out.print("${it.key}  ${it.value.type.name.toLowerCase()}  ")
@@ -485,34 +504,45 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
             }
         }
         out.println("%end_heap")
-        for(blk in blocks) {
-            out.println("\n%block ${blk.name} ${blk.address?.toString(16) ?: ""}")
+    }
 
-            out.println("%variables")
-            for(variable in blk.variables) {
-                val valuestr = variable.value.toString()
-                out.println("${variable.key}  ${variable.value.type.name.toLowerCase()}  $valuestr")
-            }
-            out.println("%end_variables")
-            out.println("%memorypointers")
-            for(iconst in blk.memoryPointers) {
-                out.println("${iconst.key}  ${iconst.value.second.name.toLowerCase()}  uw:${iconst.value.first.toString(16)}")
-            }
-            out.println("%end_memorypointers")
-            out.println("%instructions")
-            val labels = blk.labels.entries.associateBy({it.value}) {it.key}
-            for(instr in blk.instructions) {
-                if(!embeddedLabels) {
-                    val label = labels[instr]
-                    if (label != null)
-                        out.println("$label:")
-                } else {
-                    out.println(instr)
-                }
-            }
-            out.println("%end_instructions")
+    private fun writeBlock(out: PrintStream, blk: ProgramBlock, embeddedLabels: Boolean) {
+        out.println("\n%block ${blk.name} ${blk.address?.toString(16) ?: ""}")
 
-            out.println("%end_block")
+        out.println("%variables")
+        for (variable in blk.variables) {
+            if(variable.params.zp==ZeropageWish.REQUIRE_ZEROPAGE)
+                throw CompilerException("zp conflict")
+            val valuestr = variable.value.toString()
+            val struct =  if(variable.params.memberOfStruct==null) "" else "struct=${variable.params.memberOfStruct.name}"
+            out.println("${variable.scopedname}  ${variable.value.type.name.toLowerCase()}  $valuestr  zp=${variable.params.zp} s=$struct")
         }
+        out.println("%end_variables")
+        out.println("%memorypointers")
+        for (iconst in blk.memoryPointers) {
+            out.println("${iconst.key}  ${iconst.value.second.name.toLowerCase()}  uw:${iconst.value.first.toString(16)}")
+        }
+        out.println("%end_memorypointers")
+        out.println("%instructions")
+        val labels = blk.labels.entries.associateBy({ it.value }) { it.key }
+        for (instr in blk.instructions) {
+            if (!embeddedLabels) {
+                val label = labels[instr]
+                if (label != null)
+                    out.println("$label:")
+            } else {
+                out.println(instr)
+            }
+        }
+        out.println("%end_instructions")
+
+        out.println("%end_block")
+    }
+
+    private fun writeMemory(out: PrintStream) {
+        out.println("%memory")
+        if (memory.isNotEmpty())
+            TODO("add support for writing/reading initial memory values")
+        out.println("%end_memory")
     }
 }

DeprecatedStackVm/src/compiler/intermediate/Opcode.kt

@@ -1,4 +1,4 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
 enum class Opcode {
 
@@ -19,6 +19,8 @@ enum class Opcode {
     PUSH_REGAY_WORD, // push registers A/Y as a 16-bit word
     PUSH_REGXY_WORD, // push registers X/Y as a 16-bit word
     PUSH_ADDR_HEAPVAR,  // push the address of the variable that's on the heap (string or array)
+    DUP_B,          // duplicate the top byte on the stack
+    DUP_W,          // duplicate the top word on the stack
 
     // popping values off the (evaluation) stack, possibly storing them in another location
     DISCARD_BYTE,    // discard top byte value

DeprecatedStackVm/src/compiler/target/c64/codegen/AsmGen.kt

@@ -0,0 +1,761 @@
+package compiler.target.c64.codegen
+
+// note: to put stuff on the stack, we use Absolute,X  addressing mode which is 3 bytes / 4 cycles
+// possible space optimization is to use zeropage (indirect),Y  which is 2 bytes, but 5 cycles
+
+import prog8.ast.antlr.escape
+import prog8.ast.base.DataType
+import prog8.ast.base.initvarsSubName
+import prog8.ast.statements.ZeropageWish
+import prog8.compiler.*
+import prog8.compiler.intermediate.Instruction
+import prog8.compiler.intermediate.IntermediateProgram
+import prog8.compiler.intermediate.LabelInstr
+import prog8.compiler.intermediate.Opcode
+import prog8.compiler.target.c64.AssemblyProgram
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.Petscii
+import prog8.vm.RuntimeValue
+import java.io.File
+import java.util.*
+import kotlin.math.abs
+
+
+class AssemblyError(msg: String) : RuntimeException(msg)
+
+
+
+internal fun intVal(valueInstr: Instruction) = valueInstr.arg!!.integerValue()
+internal fun hexVal(valueInstr: Instruction) = valueInstr.arg!!.integerValue().toHex()
+internal fun hexValPlusOne(valueInstr: Instruction) = (valueInstr.arg!!.integerValue()+1).toHex()
+internal fun getFloatConst(value: RuntimeValue): String =
+        globalFloatConsts[value.numericValue().toDouble()]
+                ?: throw AssemblyError("should have a global float const for number $value")
+
+internal val globalFloatConsts = mutableMapOf<Double, String>()
+
+internal fun signExtendA(into: String) =
+        """
+        ora  #$7f
+        bmi  +
+        lda  #0
++       sta  $into
+        """
+
+class AsmGen(private val options: CompilationOptions, private val program: IntermediateProgram,
+             private val heap: HeapValues, private val zeropage: Zeropage) {
+    private val assemblyLines = mutableListOf<String>()
+    private lateinit var block: IntermediateProgram.ProgramBlock
+
+    init {
+        // Convert invalid label names (such as "<anon-1>") to something that's allowed.
+        val newblocks = mutableListOf<IntermediateProgram.ProgramBlock>()
+        for(block in program.blocks) {
+            val newvars = block.variables.map { IntermediateProgram.Variable(symname(it.scopedname, block), it.value, it.params) }.toMutableList()
+            val newlabels = block.labels.map { symname(it.key, block) to it.value}.toMap().toMutableMap()
+            val newinstructions = block.instructions.asSequence().map {
+                when {
+                    it is LabelInstr -> LabelInstr(symname(it.name, block), it.asmProc)
+                    it.opcode == Opcode.INLINE_ASSEMBLY -> it
+                    else ->
+                        Instruction(it.opcode, it.arg, it.arg2,
+                            callLabel = if (it.callLabel != null) symname(it.callLabel, block) else null,
+                            callLabel2 = if (it.callLabel2 != null) symname(it.callLabel2, block) else null)
+                }
+            }.toMutableList()
+            val newMempointers = block.memoryPointers.map { symname(it.key, block) to it.value }.toMap().toMutableMap()
+            val newblock = IntermediateProgram.ProgramBlock(
+                    block.name,
+                    block.address,
+                    newinstructions,
+                    newvars,
+                    newMempointers,
+                    newlabels,
+                    force_output = block.force_output)
+            newblocks.add(newblock)
+        }
+        program.blocks.clear()
+        program.blocks.addAll(newblocks)
+
+        val newAllocatedZp = program.allocatedZeropageVariables.map { symname(it.key, null) to it.value}
+        program.allocatedZeropageVariables.clear()
+        program.allocatedZeropageVariables.putAll(newAllocatedZp)
+
+        // make a list of all const floats that are used
+        for(block in program.blocks) {
+            for(ins in block.instructions.filter{it.arg?.type== DataType.FLOAT}) {
+                val float = ins.arg!!.numericValue().toDouble()
+                if(float !in globalFloatConsts)
+                    globalFloatConsts[float] = "prog8_const_float_${globalFloatConsts.size}"
+            }
+        }
+    }
+
+    fun compileToAssembly(optimize: Boolean): AssemblyProgram {
+        println("Generating assembly code from intermediate code... ")
+
+        assemblyLines.clear()
+        header()
+        for(b in program.blocks)
+            block2asm(b)
+
+        if(optimize) {
+            var optimizationsDone = 1
+            while (optimizationsDone > 0) {
+                optimizationsDone = optimizeAssembly(assemblyLines)
+            }
+        }
+
+        File("${program.name}.asm").printWriter().use {
+            for (line in assemblyLines) { it.println(line) }
+        }
+
+        return AssemblyProgram(program.name)
+    }
+
+    private fun out(str: String, splitlines: Boolean=true) {
+        if(splitlines) {
+            for (line in str.split('\n')) {
+                val trimmed = if (line.startsWith(' ')) "\t" + line.trim() else line.trim()
+                // trimmed = trimmed.replace(Regex("^\\+\\s+"), "+\t")  // sanitize local label indentation
+                assemblyLines.add(trimmed)
+            }
+        } else assemblyLines.add(str)
+    }
+
+
+    // convert a fully scoped name (defined in the given block) to a valid assembly symbol name
+    private fun symname(scoped: String, block: IntermediateProgram.ProgramBlock?): String {
+        if(' ' in scoped)
+            return scoped
+        val blockLocal: Boolean
+        var name = if (block!=null && scoped.startsWith("${block.name}.")) {
+            blockLocal = true
+            scoped.substring(block.name.length+1)
+        }
+        else {
+            blockLocal = false
+            scoped
+        }
+        name = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
+        if(name=="-")
+            return "-"
+        if(blockLocal)
+            name = name.replace(".", "_")
+        else {
+            val parts = name.split(".", limit=2)
+            if(parts.size>1)
+                name = "${parts[0]}.${parts[1].replace(".", "_")}"
+        }
+        return name.replace("-", "")
+    }
+
+    private fun makeFloatFill(flt: MachineDefinition.Mflpt5): String {
+        val b0 = "$"+flt.b0.toString(16).padStart(2, '0')
+        val b1 = "$"+flt.b1.toString(16).padStart(2, '0')
+        val b2 = "$"+flt.b2.toString(16).padStart(2, '0')
+        val b3 = "$"+flt.b3.toString(16).padStart(2, '0')
+        val b4 = "$"+flt.b4.toString(16).padStart(2, '0')
+        return "$b0, $b1, $b2, $b3, $b4"
+    }
+
+    private fun header() {
+        val ourName = this.javaClass.name
+        out("; 6502 assembly code for '${program.name}'")
+        out("; generated by $ourName on ${Date()}")
+        out("; assembler syntax is for the 64tasm cross-assembler")
+        out("; output options: output=${options.output} launcher=${options.launcher} zp=${options.zeropage}")
+        out("\n.cpu  '6502'\n.enc  'none'\n")
+
+        if(program.loadAddress==0)   // fix load address
+            program.loadAddress = if(options.launcher==LauncherType.BASIC)
+                MachineDefinition.BASIC_LOAD_ADDRESS else MachineDefinition.RAW_LOAD_ADDRESS
+
+        when {
+            options.launcher == LauncherType.BASIC -> {
+                if (program.loadAddress != 0x0801)
+                    throw AssemblyError("BASIC output must have load address $0801")
+                out("; ---- basic program with sys call ----")
+                out("* = ${program.loadAddress.toHex()}")
+                val year = Calendar.getInstance().get(Calendar.YEAR)
+                out("  .word  (+), $year")
+                out("  .null  $9e, format(' %d ', _prog8_entrypoint), $3a, $8f, ' prog8 by idj'")
+                out("+\t.word  0")
+                out("_prog8_entrypoint\t; assembly code starts here\n")
+                out("  jsr  prog8_lib.init_system")
+            }
+            options.output == OutputType.PRG -> {
+                out("; ---- program without basic sys call ----")
+                out("* = ${program.loadAddress.toHex()}\n")
+                out("  jsr  prog8_lib.init_system")
+            }
+            options.output == OutputType.RAW -> {
+                out("; ---- raw assembler program ----")
+                out("* = ${program.loadAddress.toHex()}\n")
+            }
+        }
+
+        if(zeropage.exitProgramStrategy!=Zeropage.ExitProgramStrategy.CLEAN_EXIT) {
+            // disable shift-commodore charset switching and run/stop key
+            out("  lda  #$80")
+            out("  lda  #$80")
+            out("  sta  657\t; disable charset switching")
+            out("  lda  #239")
+            out("  sta  808\t; disable run/stop key")
+        }
+
+        out("  ldx  #\$ff\t; init estack pointer")
+        out("  ; initialize the variables in each block")
+        for(block in program.blocks) {
+            val initVarsLabel = block.instructions.firstOrNull { it is LabelInstr && it.name== initvarsSubName } as? LabelInstr
+            if(initVarsLabel!=null)
+                out("  jsr  ${block.name}.${initVarsLabel.name}")
+        }
+        out("  clc")
+        when(zeropage.exitProgramStrategy) {
+            Zeropage.ExitProgramStrategy.CLEAN_EXIT -> {
+                out("  jmp  main.start\t; jump to program entrypoint")
+            }
+            Zeropage.ExitProgramStrategy.SYSTEM_RESET -> {
+                out("  jsr  main.start\t; call program entrypoint")
+                out("  jmp  (c64.RESET_VEC)\t; cold reset")
+            }
+        }
+        out("")
+
+        // the global list of all floating point constants for the whole program
+        for(flt in globalFloatConsts) {
+            val floatFill = makeFloatFill(MachineDefinition.Mflpt5.fromNumber(flt.key))
+            out("${flt.value}\t.byte  $floatFill  ; float ${flt.key}")
+        }
+    }
+
+    private fun block2asm(blk: IntermediateProgram.ProgramBlock) {
+        block = blk
+        out("\n; ---- block: '${block.name}' ----")
+        if(!blk.force_output)
+            out("${block.name}\t.proc\n")
+        if(block.address!=null) {
+            out(".cerror * > ${block.address?.toHex()}, 'block address overlaps by ', *-${block.address?.toHex()},' bytes'")
+            out("* = ${block.address?.toHex()}")
+        }
+
+        // deal with zeropage variables
+        for(variable in blk.variables) {
+            val sym = symname(blk.name+"."+variable.scopedname, null)
+            val zpVar = program.allocatedZeropageVariables[sym]
+            if(zpVar==null) {
+                // This var is not on the ZP yet. Attempt to move it there (if it's not a float, those take up too much space)
+                if(variable.params.zp != ZeropageWish.NOT_IN_ZEROPAGE &&
+                        variable.value.type in zeropage.allowedDatatypes
+                        && variable.value.type != DataType.FLOAT) {
+                    try {
+                        val address = zeropage.allocate(sym, variable.value.type, null)
+                        out("${variable.scopedname} = $address\t; auto zp ${variable.value.type}")
+                        // make sure we add the var to the set of zpvars for this block
+                        program.allocatedZeropageVariables[sym] = Pair(address, variable.value.type)
+                    } catch (x: ZeropageDepletedError) {
+                        // leave it as it is.
+                    }
+                }
+            }
+            else {
+                // it was already allocated on the zp
+                out("${variable.scopedname} = ${zpVar.first}\t; zp ${zpVar.second}")
+            }
+        }
+
+        out("\n; memdefs and kernel subroutines")
+        memdefs2asm(block)
+        out("\n; non-zeropage variables")
+        vardecls2asm(block)
+        out("")
+
+        val instructionPatternWindowSize = 8        // increase once patterns occur longer than this.
+        var processed = 0
+
+        for (ins in block.instructions.windowed(instructionPatternWindowSize, partialWindows = true)) {
+            if (processed == 0) {
+                processed = instr2asm(ins)
+                if (processed == 0) {
+                    // the instructions are not recognised yet and can't be translated into assembly
+                    throw CompilerException("no asm translation found for instruction pattern: $ins")
+                }
+            }
+            processed--
+        }
+        if(!blk.force_output)
+            out("\n\t.pend\n")
+    }
+
+    private fun memdefs2asm(block: IntermediateProgram.ProgramBlock) {
+        for(m in block.memoryPointers) {
+            out("  ${m.key} = ${m.value.first.toHex()}")
+        }
+    }
+
+    private fun vardecls2asm(block: IntermediateProgram.ProgramBlock) {
+        val uniqueNames = block.variables.map { it.scopedname }.toSet()
+        if (uniqueNames.size != block.variables.size)
+            throw AssemblyError("not all variables have unique names")
+
+        // these are the non-zeropage variables.
+        // first get all the flattened struct members, they MUST remain in order
+        out(";  flattened struct members")
+        val (structMembers, normalVars) = block.variables.partition { it.params.memberOfStruct!=null }
+        structMembers.forEach { vardecl2asm(it.scopedname, it.value, it.params) }
+
+        // sort the other variables by type
+        out(";  other variables sorted by type")
+        val sortedVars = normalVars.sortedBy { it.value.type }
+        for (variable in sortedVars) {
+            val sym = symname(block.name + "." + variable.scopedname, null)
+            if(sym in program.allocatedZeropageVariables)
+                continue  // skip the ones that already belong in the zero page
+            vardecl2asm(variable.scopedname, variable.value, variable.params)
+        }
+    }
+
+    private fun vardecl2asm(varname: String, value: RuntimeValue, parameters: IntermediateProgram.VariableParameters) {
+        when (value.type) {
+            DataType.UBYTE -> out("$varname\t.byte  0")
+            DataType.BYTE -> out("$varname\t.char  0")
+            DataType.UWORD -> out("$varname\t.word  0")
+            DataType.WORD -> out("$varname\t.sint  0")
+            DataType.FLOAT -> out("$varname\t.byte  0,0,0,0,0  ; float")
+            DataType.STR, DataType.STR_S -> {
+                val rawStr = heap.get(value.heapId!!).str!!
+                val bytes = encodeStr(rawStr, value.type).map { "$" + it.toString(16).padStart(2, '0') }
+                out("$varname\t; ${value.type} \"${escape(rawStr).replace("\u0000", "<NULL>")}\"")
+                for (chunk in bytes.chunked(16))
+                    out("  .byte  " + chunk.joinToString())
+            }
+            DataType.ARRAY_UB -> {
+                // unsigned integer byte arraysize
+                val data = makeArrayFillDataUnsigned(value)
+                if (data.size <= 16)
+                    out("$varname\t.byte  ${data.joinToString()}")
+                else {
+                    out(varname)
+                    for (chunk in data.chunked(16))
+                        out("  .byte  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_B -> {
+                // signed integer byte arraysize
+                val data = makeArrayFillDataSigned(value)
+                if (data.size <= 16)
+                    out("$varname\t.char  ${data.joinToString()}")
+                else {
+                    out(varname)
+                    for (chunk in data.chunked(16))
+                        out("  .char  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_UW -> {
+                // unsigned word arraysize
+                val data = makeArrayFillDataUnsigned(value)
+                if (data.size <= 16)
+                    out("$varname\t.word  ${data.joinToString()}")
+                else {
+                    out(varname)
+                    for (chunk in data.chunked(16))
+                        out("  .word  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_W -> {
+                // signed word arraysize
+                val data = makeArrayFillDataSigned(value)
+                if (data.size <= 16)
+                    out("$varname\t.sint  ${data.joinToString()}")
+                else {
+                    out(varname)
+                    for (chunk in data.chunked(16))
+                        out("  .sint  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_F -> {
+                // float arraysize
+                val array = heap.get(value.heapId!!).doubleArray!!
+                val floatFills = array.map { makeFloatFill(MachineDefinition.Mflpt5.fromNumber(it)) }
+                out(varname)
+                for (f in array.zip(floatFills))
+                    out("  .byte  ${f.second}  ; float ${f.first}")
+            }
+            DataType.STRUCT -> throw AssemblyError("vars of type STRUCT should have been removed because flattened")
+        }
+    }
+
+
+    private fun encodeStr(str: String, dt: DataType): List<Short> {
+        return when(dt) {
+            DataType.STR -> {
+                val bytes = Petscii.encodePetscii(str, true)
+                bytes.plus(0)
+            }
+            DataType.STR_S -> {
+                val bytes = Petscii.encodeScreencode(str, true)
+                bytes.plus(0)
+            }
+            else -> throw AssemblyError("invalid str type")
+        }
+    }
+
+    private fun makeArrayFillDataUnsigned(value: RuntimeValue): List<String> {
+        val array = heap.get(value.heapId!!).array!!
+        return when {
+            value.type== DataType.ARRAY_UB ->
+                // byte array can never contain pointer-to types, so treat values as all integers
+                array.map { "$"+it.integer!!.toString(16).padStart(2, '0') }
+            value.type== DataType.ARRAY_UW -> array.map {
+                when {
+                    it.integer!=null -> "$"+it.integer.toString(16).padStart(2, '0')
+                    it.addressOf!=null -> symname(it.addressOf.scopedname!!, block)
+                    else -> throw AssemblyError("weird type in array")
+                }
+            }
+            else -> throw AssemblyError("invalid arraysize type")
+        }
+    }
+
+    private fun makeArrayFillDataSigned(value: RuntimeValue): List<String> {
+        val array = heap.get(value.heapId!!).array!!
+        // note: array of signed value can never contain pointer-to type, so simply accept values as being all integers
+        return if (value.type == DataType.ARRAY_B || value.type == DataType.ARRAY_W) {
+            array.map {
+                if(it.integer!!>=0)
+                    "$"+it.integer.toString(16).padStart(2, '0')
+                else
+                    "-$"+abs(it.integer).toString(16).padStart(2, '0')
+            }
+        }
+        else throw AssemblyError("invalid arraysize type")
+    }
+
+    private fun instr2asm(ins: List<Instruction>): Int {
+        // find best patterns (matching the most of the lines, then with the smallest weight)
+        val fragments = findPatterns(ins).sortedByDescending { it.segmentSize }
+        if(fragments.isEmpty()) {
+            // we didn't find any matching patterns (complex multi-instruction fragments), try simple ones
+            val firstIns = ins[0]
+            val singleAsm = simpleInstr2Asm(firstIns, block)
+            if(singleAsm != null) {
+                outputAsmFragment(singleAsm)
+                return 1
+            }
+            return 0
+        }
+        val best = fragments[0]
+        outputAsmFragment(best.asm)
+        return best.segmentSize
+    }
+
+    private fun outputAsmFragment(singleAsm: String) {
+        if (singleAsm.isNotEmpty()) {
+            if(singleAsm.startsWith("@inline@"))
+                out(singleAsm.substring(8), false)
+            else {
+                val withNewlines = singleAsm.replace('|', '\n')
+                out(withNewlines)
+            }
+        }
+    }
+
+    private fun findPatterns(segment: List<Instruction>): List<AsmFragment> {
+        val opcodes = segment.map { it.opcode }
+        val result = mutableListOf<AsmFragment>()
+
+        // check for operations that modify a single value, by putting it on the stack (and popping it afterwards)
+        if((opcodes[0]==Opcode.PUSH_VAR_BYTE && opcodes[2]==Opcode.POP_VAR_BYTE) ||
+                (opcodes[0]==Opcode.PUSH_VAR_WORD && opcodes[2]==Opcode.POP_VAR_WORD) ||
+                (opcodes[0]==Opcode.PUSH_VAR_FLOAT && opcodes[2]==Opcode.POP_VAR_FLOAT)) {
+            if (segment[0].callLabel == segment[2].callLabel) {
+                val fragment = sameVarOperation(segment[0].callLabel!!, segment[1])
+                if (fragment != null) {
+                    fragment.segmentSize = 3
+                    result.add(fragment)
+                }
+            }
+        }
+        else if((opcodes[0]==Opcode.PUSH_BYTE && opcodes[1] in setOf(Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB,
+                        Opcode.INC_INDEXED_VAR_UW, Opcode.INC_INDEXED_VAR_W, Opcode.INC_INDEXED_VAR_FLOAT,
+                        Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB, Opcode.DEC_INDEXED_VAR_W,
+                        Opcode.DEC_INDEXED_VAR_UW, Opcode.DEC_INDEXED_VAR_FLOAT))) {
+            val fragment = sameConstantIndexedVarOperation(segment[1].callLabel!!, segment[0].arg!!.integerValue(), segment[1])
+            if(fragment!=null) {
+                fragment.segmentSize=2
+                result.add(fragment)
+            }
+        }
+        else if((opcodes[0]==Opcode.PUSH_VAR_BYTE && opcodes[1] in setOf(Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB,
+                        Opcode.INC_INDEXED_VAR_UW, Opcode.INC_INDEXED_VAR_W, Opcode.INC_INDEXED_VAR_FLOAT,
+                        Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB, Opcode.DEC_INDEXED_VAR_W,
+                        Opcode.DEC_INDEXED_VAR_UW, Opcode.DEC_INDEXED_VAR_FLOAT))) {
+            val fragment = sameIndexedVarOperation(segment[1].callLabel!!, segment[0].callLabel!!, segment[1])
+            if(fragment!=null) {
+                fragment.segmentSize=2
+                result.add(fragment)
+            }
+        }
+        else if((opcodes[0]==Opcode.PUSH_MEM_UB && opcodes[2]==Opcode.POP_MEM_BYTE) ||
+                (opcodes[0]==Opcode.PUSH_MEM_B && opcodes[2]==Opcode.POP_MEM_BYTE) ||
+                (opcodes[0]==Opcode.PUSH_MEM_UW && opcodes[2]==Opcode.POP_MEM_WORD) ||
+                (opcodes[0]==Opcode.PUSH_MEM_W && opcodes[2]==Opcode.POP_MEM_WORD) ||
+                (opcodes[0]==Opcode.PUSH_MEM_FLOAT && opcodes[2]==Opcode.POP_MEM_FLOAT)) {
+            if(segment[0].arg==segment[2].arg) {
+                val fragment = sameMemOperation(segment[0].arg!!.integerValue(), segment[1])
+                if(fragment!=null) {
+                    fragment.segmentSize = 3
+                    result.add(fragment)
+                }
+            }
+        }
+        else if((opcodes[0]==Opcode.PUSH_BYTE && opcodes[1]==Opcode.READ_INDEXED_VAR_BYTE &&
+                        opcodes[3]==Opcode.PUSH_BYTE && opcodes[4]==Opcode.WRITE_INDEXED_VAR_BYTE) ||
+                (opcodes[0]==Opcode.PUSH_BYTE && opcodes[1]==Opcode.READ_INDEXED_VAR_WORD &&
+                        opcodes[3]==Opcode.PUSH_BYTE && opcodes[4]==Opcode.WRITE_INDEXED_VAR_WORD)) {
+            if(segment[0].arg==segment[3].arg && segment[1].callLabel==segment[4].callLabel) {
+                val fragment = sameConstantIndexedVarOperation(segment[1].callLabel!!, segment[0].arg!!.integerValue(), segment[2])
+                if(fragment!=null){
+                    fragment.segmentSize = 5
+                    result.add(fragment)
+                }
+            }
+        }
+        else if((opcodes[0]==Opcode.PUSH_VAR_BYTE && opcodes[1]==Opcode.READ_INDEXED_VAR_BYTE &&
+                        opcodes[3]==Opcode.PUSH_VAR_BYTE && opcodes[4]==Opcode.WRITE_INDEXED_VAR_BYTE) ||
+                (opcodes[0]==Opcode.PUSH_VAR_BYTE && opcodes[1]==Opcode.READ_INDEXED_VAR_WORD &&
+                        opcodes[3]==Opcode.PUSH_VAR_BYTE && opcodes[4]==Opcode.WRITE_INDEXED_VAR_WORD)) {
+            if(segment[0].callLabel==segment[3].callLabel && segment[1].callLabel==segment[4].callLabel) {
+                val fragment = sameIndexedVarOperation(segment[1].callLabel!!, segment[0].callLabel!!, segment[2])
+                if(fragment!=null){
+                    fragment.segmentSize = 5
+                    result.add(fragment)
+                }
+            }
+        }
+
+        // add any matching patterns from the big list
+        for(pattern in Patterns.patterns) {
+            if(pattern.sequence.size > segment.size || (pattern.altSequence!=null && pattern.altSequence.size > segment.size))
+                continue        //  don't accept patterns that don't fit
+            val opcodesList = opcodes.subList(0, pattern.sequence.size)
+            if(pattern.sequence == opcodesList) {
+                val asm = pattern.asm(segment)
+                if(asm!=null)
+                    result.add(AsmFragment(asm, pattern.sequence.size))
+            } else if(pattern.altSequence!=null) {
+                val opcodesListAlt = opcodes.subList(0, pattern.altSequence.size)
+                if(pattern.altSequence == opcodesListAlt) {
+                    val asm = pattern.asm(segment)
+                    if (asm != null)
+                        result.add(AsmFragment(asm, pattern.sequence.size))
+                }
+            }
+        }
+
+        return result
+    }
+
+    private fun sameConstantIndexedVarOperation(variable: String, index: Int, ins: Instruction): AsmFragment? {
+        // an in place operation that consists of a push-value / op / push-index-value / pop-into-indexed-var
+        return when(ins.opcode) {
+            Opcode.SHL_BYTE -> AsmFragment(" asl  $variable+$index", 8)
+            Opcode.SHR_UBYTE -> AsmFragment(" lsr  $variable+$index", 8)
+            Opcode.SHR_SBYTE -> AsmFragment(" lda  $variable+$index |  asl  a |  ror  $variable+$index")
+            Opcode.SHL_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
+            Opcode.SHR_UWORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.SHR_SWORD -> AsmFragment(" lda  $variable+${index * 2 + 1} |  asl  a |  ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.ROL_BYTE -> AsmFragment(" rol  $variable+$index", 8)
+            Opcode.ROR_BYTE -> AsmFragment(" ror  $variable+$index", 8)
+            Opcode.ROL_WORD -> AsmFragment(" rol  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
+            Opcode.ROR_WORD -> AsmFragment(" ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.ROL2_BYTE -> AsmFragment(" lda  $variable+$index |  cmp  #\$80 |  rol  $variable+$index", 8)
+            Opcode.ROR2_BYTE -> AsmFragment(" lda  $variable+$index |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $variable+$index", 10)
+            Opcode.ROL2_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2} |  bcc  + |  inc  $variable+${index * 2 + 1} |+", 20)
+            Opcode.ROR2_WORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2} |  bcc  + |  lda  $variable+${index * 2 + 1} |  ora  #\$80 |  sta  $variable+${index * 2 + 1} |+", 30)
+            Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB -> AsmFragment(" inc  $variable+$index", 2)
+            Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB -> AsmFragment(" dec  $variable+$index", 5)
+            Opcode.INC_INDEXED_VAR_W, Opcode.INC_INDEXED_VAR_UW -> AsmFragment(" inc  $variable+${index * 2} |  bne  + |  inc  $variable+${index * 2 + 1} |+")
+            Opcode.DEC_INDEXED_VAR_W, Opcode.DEC_INDEXED_VAR_UW -> AsmFragment(" lda  $variable+${index * 2} |  bne  + |  dec  $variable+${index * 2 + 1} |+ |  dec  $variable+${index * 2}")
+            Opcode.INC_INDEXED_VAR_FLOAT -> AsmFragment(
+                    """
+                lda  #<($variable+${index * MachineDefinition.Mflpt5.MemorySize})
+                ldy  #>($variable+${index * MachineDefinition.Mflpt5.MemorySize})
+                jsr  c64flt.inc_var_f
+                """)
+            Opcode.DEC_INDEXED_VAR_FLOAT -> AsmFragment(
+                    """
+                lda  #<($variable+${index * MachineDefinition.Mflpt5.MemorySize})
+                ldy  #>($variable+${index * MachineDefinition.Mflpt5.MemorySize})
+                jsr  c64flt.dec_var_f
+                """)
+
+            else -> null
+        }
+    }
+
+    private fun sameIndexedVarOperation(variable: String, indexVar: String, ins: Instruction): AsmFragment? {
+        // an in place operation that consists of a push-value / op / push-index-var / pop-into-indexed-var
+        val saveX = " stx  ${MachineDefinition.C64Zeropage.SCRATCH_B1} |"
+        val restoreX = " | ldx  ${MachineDefinition.C64Zeropage.SCRATCH_B1}"
+        val loadXWord: String
+        val loadX: String
+
+        when(indexVar) {
+            "X" -> {
+                loadX = ""
+                loadXWord = " txa |  asl  a |  tax |"
+            }
+            "Y" -> {
+                loadX = " tya |  tax |"
+                loadXWord = " tya |  asl  a |  tax |"
+            }
+            "A" -> {
+                loadX = " tax |"
+                loadXWord = " asl  a |  tax |"
+            }
+            else -> {
+                // the indexvar is a real variable, not a register
+                loadX = " ldx  $indexVar |"
+                loadXWord = " lda  $indexVar |  asl  a |  tax |"
+            }
+        }
+
+        return when (ins.opcode) {
+            Opcode.SHL_BYTE -> AsmFragment(" txa |  $loadX  asl  $variable,x |  tax", 10)
+            Opcode.SHR_UBYTE -> AsmFragment(" txa |  $loadX  lsr  $variable,x |  tax", 10)
+            Opcode.SHR_SBYTE -> AsmFragment("$saveX  $loadX  lda  $variable,x |  asl a |  ror  $variable,x  $restoreX", 10)
+            Opcode.SHL_WORD -> AsmFragment("$saveX $loadXWord  asl  $variable,x |  rol  $variable+1,x  $restoreX", 10)
+            Opcode.SHR_UWORD -> AsmFragment("$saveX $loadXWord  lsr  $variable+1,x |  ror  $variable,x  $restoreX", 10)
+            Opcode.SHR_SWORD -> AsmFragment("$saveX $loadXWord  lda  $variable+1,x |  asl a |  ror  $variable+1,x |  ror  $variable,x  $restoreX", 10)
+            Opcode.ROL_BYTE -> AsmFragment(" txa |  $loadX  rol  $variable,x |  tax", 10)
+            Opcode.ROR_BYTE -> AsmFragment(" txa |  $loadX  ror  $variable,x |  tax", 10)
+            Opcode.ROL_WORD -> AsmFragment("$saveX $loadXWord  rol  $variable,x |  rol  $variable+1,x  $restoreX", 10)
+            Opcode.ROR_WORD -> AsmFragment("$saveX $loadXWord  ror  $variable+1,x |  ror  $variable,x  $restoreX", 10)
+            Opcode.ROL2_BYTE -> AsmFragment("$saveX $loadX  lda  $variable,x |  cmp  #\$80 |  rol  $variable,x  $restoreX", 10)
+            Opcode.ROR2_BYTE -> AsmFragment("$saveX $loadX  lda  $variable,x |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $variable,x  $restoreX", 10)
+            Opcode.ROL2_WORD -> AsmFragment(" txa |  $loadXWord  asl  $variable,x |  rol  $variable+1,x |  bcc  + |  inc  $variable,x  |+  |  tax", 30)
+            Opcode.ROR2_WORD -> AsmFragment("$saveX $loadXWord  lsr  $variable+1,x |  ror  $variable,x |  bcc  + |  lda  $variable+1,x |  ora  #\$80 |  sta  $variable+1,x |+  $restoreX", 30)
+            Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB -> AsmFragment(" txa |  $loadX  inc  $variable,x |  tax", 10)
+            Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB -> AsmFragment(" txa |  $loadX  dec  $variable,x |  tax", 10)
+            Opcode.INC_INDEXED_VAR_W, Opcode.INC_INDEXED_VAR_UW -> AsmFragment("$saveX $loadXWord  inc  $variable,x |  bne  + |  inc  $variable+1,x  |+  $restoreX", 10)
+            Opcode.DEC_INDEXED_VAR_W, Opcode.DEC_INDEXED_VAR_UW -> AsmFragment("$saveX $loadXWord  lda  $variable,x |  bne  + |  dec  $variable+1,x |+ |  dec  $variable,x  $restoreX", 10)
+            Opcode.INC_INDEXED_VAR_FLOAT -> AsmFragment(" lda  #<$variable |  ldy  #>$variable |  $saveX   $loadX   jsr  c64flt.inc_indexed_var_f  $restoreX")
+            Opcode.DEC_INDEXED_VAR_FLOAT -> AsmFragment(" lda  #<$variable |  ldy  #>$variable |  $saveX   $loadX   jsr  c64flt.dec_indexed_var_f  $restoreX")
+
+            else -> null
+        }
+    }
+
+    private fun sameMemOperation(address: Int, ins: Instruction): AsmFragment? {
+        // an in place operation that consists of  push-mem / op / pop-mem
+        val addr = address.toHex()
+        val addrHi = (address+1).toHex()
+        return when(ins.opcode) {
+            Opcode.SHL_BYTE -> AsmFragment(" asl  $addr", 10)
+            Opcode.SHR_UBYTE -> AsmFragment(" lsr  $addr", 10)
+            Opcode.SHR_SBYTE -> AsmFragment(" lda  $addr |  asl  a |  ror  $addr", 10)
+            Opcode.SHL_WORD -> AsmFragment(" asl  $addr |  rol  $addrHi", 10)
+            Opcode.SHR_UWORD -> AsmFragment(" lsr  $addrHi |  ror  $addr", 10)
+            Opcode.SHR_SWORD -> AsmFragment(" lda  $addrHi |  asl a |  ror  $addrHi |  ror  $addr", 10)
+            Opcode.ROL_BYTE -> AsmFragment(" rol  $addr", 10)
+            Opcode.ROR_BYTE -> AsmFragment(" ror  $addr", 10)
+            Opcode.ROL_WORD -> AsmFragment(" rol  $addr |  rol  $addrHi", 10)
+            Opcode.ROR_WORD -> AsmFragment(" ror  $addrHi |  ror  $addr", 10)
+            Opcode.ROL2_BYTE -> AsmFragment(" lda  $addr |  cmp  #\$80 |  rol  $addr", 10)
+            Opcode.ROR2_BYTE -> AsmFragment(" lda  $addr |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $addr", 10)
+            Opcode.ROL2_WORD -> AsmFragment(" lda  $addr |  cmp #\$80 |  rol  $addr |  rol  $addrHi", 10)
+            Opcode.ROR2_WORD -> AsmFragment(" lsr  $addrHi |  ror  $addr |  bcc  + |  lda  $addrHi |  ora  #$80 |  sta  $addrHi |+", 20)
+            else -> null
+        }
+    }
+
+    private fun sameVarOperation(variable: String, ins: Instruction): AsmFragment? {
+        // an in place operation that consists of a push-var / op / pop-var
+        return when(ins.opcode) {
+            Opcode.SHL_BYTE -> {
+                when (variable) {
+                    "A" -> AsmFragment(" asl  a", 10)
+                    "X" -> AsmFragment(" txa |  asl  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  asl  a |  tay", 10)
+                    else -> AsmFragment(" asl  $variable", 10)
+                }
+            }
+            Opcode.SHR_UBYTE -> {
+                when (variable) {
+                    "A" -> AsmFragment(" lsr  a", 10)
+                    "X" -> AsmFragment(" txa |  lsr  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  lsr  a |  tay", 10)
+                    else -> AsmFragment(" lsr  $variable", 10)
+                }
+            }
+            Opcode.SHR_SBYTE -> {
+                // arithmetic shift right (keep sign bit)
+                when (variable) {
+                    "A" -> AsmFragment(" cmp  #$80 |  ror  a", 10)
+                    "X" -> AsmFragment(" txa |  cmp  #$80 |  ror  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  cmp  #$80 |  ror  a |  tay", 10)
+                    else -> AsmFragment(" lda  $variable |  asl  a  | ror  $variable", 10)
+                }
+            }
+            Opcode.SHL_WORD -> {
+                AsmFragment(" asl  $variable |  rol  $variable+1", 10)
+            }
+            Opcode.SHR_UWORD -> {
+                AsmFragment(" lsr  $variable+1 |  ror  $variable", 10)
+            }
+            Opcode.SHR_SWORD -> {
+                // arithmetic shift right (keep sign bit)
+                AsmFragment(" lda  $variable+1 |  asl  a |  ror  $variable+1 |  ror  $variable", 10)
+            }
+            Opcode.ROL_BYTE -> {
+                when (variable) {
+                    "A" -> AsmFragment(" rol  a", 10)
+                    "X" -> AsmFragment(" txa |  rol  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  rol  a |  tay", 10)
+                    else -> AsmFragment(" rol  $variable", 10)
+                }
+            }
+            Opcode.ROR_BYTE -> {
+                when (variable) {
+                    "A" -> AsmFragment(" ror  a", 10)
+                    "X" -> AsmFragment(" txa |  ror  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  ror  a |  tay", 10)
+                    else -> AsmFragment(" ror  $variable", 10)
+                }
+            }
+            Opcode.ROL_WORD -> {
+                AsmFragment(" rol  $variable |  rol  $variable+1", 10)
+            }
+            Opcode.ROR_WORD -> {
+                AsmFragment(" ror  $variable+1 |  ror  $variable", 10)
+            }
+            Opcode.ROL2_BYTE -> {       // 8-bit rol
+                when (variable) {
+                    "A" -> AsmFragment(" cmp  #\$80 |  rol  a", 10)
+                    "X" -> AsmFragment(" txa |  cmp  #\$80 |  rol  a |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  cmp  #\$80 |  rol  a |  tay", 10)
+                    else -> AsmFragment(" lda  $variable |  cmp  #\$80  | rol  $variable", 10)
+                }
+            }
+            Opcode.ROR2_BYTE -> {       // 8-bit ror
+                when (variable) {
+                    "A" -> AsmFragment(" lsr  a | bcc  + |  ora  #\$80  |+", 10)
+                    "X" -> AsmFragment(" txa |  lsr  a |  bcc  + |  ora  #\$80  |+ |  tax", 10)
+                    "Y" -> AsmFragment(" tya |  lsr  a |  bcc  + |  ora  #\$80  |+ |  tay", 10)
+                    else -> AsmFragment(" lda  $variable |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $variable", 10)
+                }
+            }
+            Opcode.ROL2_WORD -> {
+                AsmFragment(" lda  $variable |  cmp #\$80 |  rol  $variable |  rol  $variable+1", 10)
+            }
+            Opcode.ROR2_WORD -> {
+                AsmFragment(" lsr  $variable+1 |  ror  $variable |  bcc  + |  lda  $variable+1 |  ora  #\$80 |  sta  $variable+1 |+", 30)
+            }
+            else -> null
+        }
+    }
+
+    private class AsmFragment(val asm: String, var segmentSize: Int=0)
+}

DeprecatedStackVm/src/compiler/target/c64/codegen/SimpleAsm.kt

@@ -0,0 +1,559 @@
+package compiler.target.c64.codegen
+
+import prog8.compiler.CompilerException
+import prog8.compiler.intermediate.Instruction
+import prog8.compiler.intermediate.IntermediateProgram
+import prog8.compiler.intermediate.LabelInstr
+import prog8.compiler.intermediate.Opcode
+import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS2_HEX
+import prog8.compiler.toHex
+import prog8.vm.stackvm.Syscall
+import prog8.vm.stackvm.syscallsForStackVm
+
+
+// note: see https://wiki.nesdev.com/w/index.php/6502_assembly_optimisations
+
+
+private var breakpointCounter = 0
+
+internal fun simpleInstr2Asm(ins: Instruction, block: IntermediateProgram.ProgramBlock): String? {
+    // a label 'instruction' is simply translated into a asm label
+    if(ins is LabelInstr) {
+        val labelresult =
+                if(ins.name.startsWith("${block.name}."))
+                    ins.name.substring(block.name.length+1)
+                else
+                    ins.name
+        return if(ins.asmProc) labelresult+"\t\t.proc" else labelresult
+    }
+
+    // simple opcodes that are translated directly into one or a few asm instructions
+    return when(ins.opcode) {
+        Opcode.LINE -> " ;\tsrc line: ${ins.callLabel}"
+        Opcode.NOP -> " nop"      // shouldn't be present anymore though
+        Opcode.START_PROCDEF -> ""  // is done as part of a label
+        Opcode.END_PROCDEF -> " .pend"
+        Opcode.TERMINATE -> " brk"
+        Opcode.SEC -> " sec"
+        Opcode.CLC -> " clc"
+        Opcode.SEI -> " sei"
+        Opcode.CLI -> " cli"
+        Opcode.CARRY_TO_A -> " lda  #0 |  adc  #0"
+        Opcode.JUMP -> {
+            if(ins.callLabel!=null)
+                " jmp  ${ins.callLabel}"
+            else
+                " jmp  ${hexVal(ins)}"
+        }
+        Opcode.CALL -> {
+            if(ins.callLabel!=null)
+                " jsr  ${ins.callLabel}"
+            else
+                " jsr  ${hexVal(ins)}"
+        }
+        Opcode.RETURN -> " rts"
+        Opcode.RSAVE -> {
+            // save cpu status flag and all registers A, X, Y.
+            // see http://6502.org/tutorials/register_preservation.html
+            " php |  sta  ${C64Zeropage.SCRATCH_REG} | pha  | txa  | pha  | tya  | pha  | lda  ${C64Zeropage.SCRATCH_REG}"
+        }
+        Opcode.RRESTORE -> {
+            // restore all registers and cpu status flag
+            " pla |  tay |  pla |  tax |  pla |  plp"
+        }
+        Opcode.RSAVEX -> " sta  ${C64Zeropage.SCRATCH_REG} |  txa |  pha |  lda  ${C64Zeropage.SCRATCH_REG}"
+        Opcode.RRESTOREX -> " sta  ${C64Zeropage.SCRATCH_REG} |  pla |  tax |  lda  ${C64Zeropage.SCRATCH_REG}"
+        Opcode.DISCARD_BYTE -> " inx"
+        Opcode.DISCARD_WORD -> " inx"
+        Opcode.DISCARD_FLOAT -> " inx |  inx |  inx"
+        Opcode.DUP_B -> {
+            " lda $ESTACK_LO_PLUS1_HEX,x | sta $ESTACK_LO_HEX,x | dex | ;DUP_B "
+        }
+        Opcode.DUP_W -> {
+            " lda $ESTACK_LO_PLUS1_HEX,x | sta $ESTACK_LO_HEX,x | lda $ESTACK_HI_PLUS1_HEX,x | sta $ESTACK_HI_HEX,x | dex "
+        }
+
+        Opcode.CMP_B, Opcode.CMP_UB -> {
+            " inx | lda $ESTACK_LO_HEX,x | cmp #${ins.arg!!.integerValue().toHex()} | ;CMP_B "
+        }
+
+        Opcode.CMP_W, Opcode.CMP_UW -> {
+            """
+            inx
+            lda   $ESTACK_HI_HEX,x
+            cmp   #>${ins.arg!!.integerValue().toHex()}
+            bne   +
+            lda   $ESTACK_LO_HEX,x
+            cmp   #<${ins.arg.integerValue().toHex()}
+            ; bne   +    not necessary?
+            ; lda   #0   not necessary?
++                           
+            """
+        }
+
+        Opcode.INLINE_ASSEMBLY ->  "@inline@" + (ins.callLabel2 ?: "")      // All of the inline assembly is stored in the calllabel2 property. the '@inline@' is a special marker to accept it.
+        Opcode.INCLUDE_FILE -> {
+            val offset = if(ins.arg==null) "" else ", ${ins.arg.integerValue()}"
+            val length = if(ins.arg2==null) "" else ", ${ins.arg2.integerValue()}"
+            " .binary  \"${ins.callLabel}\" $offset $length"
+        }
+        Opcode.SYSCALL -> {
+            if (ins.arg!!.numericValue() in syscallsForStackVm.map { it.callNr })
+                throw CompilerException("cannot translate vm syscalls to real assembly calls - use *real* subroutine calls instead. Syscall ${ins.arg.numericValue()}")
+            val call = Syscall.values().find { it.callNr==ins.arg.numericValue() }
+            when(call) {
+                Syscall.FUNC_SIN,
+                Syscall.FUNC_COS,
+                Syscall.FUNC_ABS,
+                Syscall.FUNC_TAN,
+                Syscall.FUNC_ATAN,
+                Syscall.FUNC_LN,
+                Syscall.FUNC_LOG2,
+                Syscall.FUNC_SQRT,
+                Syscall.FUNC_RAD,
+                Syscall.FUNC_DEG,
+                Syscall.FUNC_ROUND,
+                Syscall.FUNC_FLOOR,
+                Syscall.FUNC_CEIL,
+                Syscall.FUNC_RNDF,
+                Syscall.FUNC_ANY_F,
+                Syscall.FUNC_ALL_F,
+                Syscall.FUNC_MAX_F,
+                Syscall.FUNC_MIN_F,
+                Syscall.FUNC_SUM_F -> " jsr  c64flt.${call.name.toLowerCase()}"
+                null -> ""
+                else -> " jsr  prog8_lib.${call.name.toLowerCase()}"
+            }
+        }
+        Opcode.BREAKPOINT -> {
+            breakpointCounter++
+            "_prog8_breakpoint_$breakpointCounter\tnop"
+        }
+
+        Opcode.PUSH_BYTE -> {
+            " lda  #${hexVal(ins)} |  sta  $ESTACK_LO_HEX,x |  dex"
+        }
+        Opcode.PUSH_WORD -> {
+            val value = hexVal(ins)
+            " lda  #<$value |  sta  $ESTACK_LO_HEX,x |  lda  #>$value |  sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.PUSH_FLOAT -> {
+            val floatConst = getFloatConst(ins.arg!!)
+            " lda  #<$floatConst |  ldy  #>$floatConst |  jsr  c64flt.push_float"
+        }
+        Opcode.PUSH_VAR_BYTE -> {
+            when(ins.callLabel) {
+                "X" -> throw CompilerException("makes no sense to push X, it's used as a stack pointer itself. You should probably not use the X register (or only in trivial assignments)")
+                "A" -> " sta  $ESTACK_LO_HEX,x |  dex"
+                "Y" -> " tya |  sta  $ESTACK_LO_HEX,x |  dex"
+                else -> " lda  ${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  dex"
+            }
+        }
+        Opcode.PUSH_VAR_WORD -> {
+            " lda  ${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  lda  ${ins.callLabel}+1 |    sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.PUSH_VAR_FLOAT -> " lda  #<${ins.callLabel} |  ldy  #>${ins.callLabel}|  jsr  c64flt.push_float"
+        Opcode.PUSH_MEM_B, Opcode.PUSH_MEM_UB -> {
+            """
+                lda  ${hexVal(ins)}
+                sta  $ESTACK_LO_HEX,x
+                dex
+                """
+        }
+        Opcode.PUSH_MEM_W, Opcode.PUSH_MEM_UW -> {
+            """
+                lda  ${hexVal(ins)}
+                sta  $ESTACK_LO_HEX,x
+                lda  ${hexValPlusOne(ins)}
+                sta  $ESTACK_HI_HEX,x
+                dex
+                """
+        }
+        Opcode.PUSH_MEM_FLOAT -> {
+            " lda  #<${hexVal(ins)} |  ldy  #>${hexVal(ins)}|  jsr  c64flt.push_float"
+        }
+        Opcode.PUSH_MEMREAD -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_PLUS1_HEX,x
+                sta  (+) +2
++               lda  65535    ; modified
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+
+        Opcode.PUSH_REGAY_WORD -> {
+            " sta  $ESTACK_LO_HEX,x |  tya |  sta  $ESTACK_HI_HEX,x |  dex "
+        }
+        Opcode.PUSH_ADDR_HEAPVAR -> {
+            " lda  #<${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  lda  #>${ins.callLabel}  |  sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.POP_REGAX_WORD -> throw AssemblyError("cannot load X register from stack because it's used as the stack pointer itself")
+        Opcode.POP_REGXY_WORD -> throw AssemblyError("cannot load X register from stack because it's used as the stack pointer itself")
+        Opcode.POP_REGAY_WORD -> {
+            " inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x "
+        }
+
+        Opcode.READ_INDEXED_VAR_BYTE -> {
+            """
+                ldy  $ESTACK_LO_PLUS1_HEX,x
+                lda  ${ins.callLabel},y
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.READ_INDEXED_VAR_WORD -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                asl  a
+                tay
+                lda  ${ins.callLabel},y
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                lda  ${ins.callLabel}+1,y
+                sta  $ESTACK_HI_PLUS1_HEX,x
+                """
+        }
+        Opcode.READ_INDEXED_VAR_FLOAT -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.push_float_from_indexed_var
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_BYTE -> {
+            """
+                inx
+                ldy  $ESTACK_LO_HEX,x
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${ins.callLabel},y
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_WORD -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                asl  a
+                tay
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${ins.callLabel},y
+                lda  $ESTACK_HI_HEX,x
+                sta  ${ins.callLabel}+1,y
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_FLOAT -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.pop_float_to_indexed_var
+                """
+        }
+        Opcode.POP_MEM_BYTE -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${hexVal(ins)}
+                """
+        }
+        Opcode.POP_MEM_WORD -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${hexVal(ins)}
+                lda  $ESTACK_HI_HEX,x
+                sta  ${hexValPlusOne(ins)}
+                """
+        }
+        Opcode.POP_MEM_FLOAT -> {
+            " lda  ${hexVal(ins)} |  ldy  ${hexValPlusOne(ins)} |  jsr  c64flt.pop_float"
+        }
+        Opcode.POP_MEMWRITE -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
+                inx
+                lda  $ESTACK_LO_HEX,x
++               sta  65535       ; modified
+                """
+        }
+
+        Opcode.POP_VAR_BYTE -> {
+            when (ins.callLabel) {
+                "X" -> throw CompilerException("makes no sense to pop X, it's used as a stack pointer itself")
+                "A" -> " inx |  lda  $ESTACK_LO_HEX,x"
+                "Y" -> " inx |  ldy  $ESTACK_LO_HEX,x"
+                else -> " inx |  lda  $ESTACK_LO_HEX,x |  sta  ${ins.callLabel}"
+            }
+        }
+        Opcode.POP_VAR_WORD -> {
+            " inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x |  sta  ${ins.callLabel} |  sty  ${ins.callLabel}+1"
+        }
+        Opcode.POP_VAR_FLOAT -> {
+            " lda  #<${ins.callLabel} |  ldy  #>${ins.callLabel} |  jsr  c64flt.pop_float"
+        }
+
+        Opcode.INC_VAR_UB, Opcode.INC_VAR_B -> {
+            when (ins.callLabel) {
+                "A" -> " clc |  adc  #1"
+                "X" -> " inx"
+                "Y" -> " iny"
+                else -> " inc  ${ins.callLabel}"
+            }
+        }
+        Opcode.INC_VAR_UW, Opcode.INC_VAR_W -> {
+            " inc  ${ins.callLabel} |  bne  + |  inc  ${ins.callLabel}+1 |+"
+        }
+        Opcode.INC_VAR_F -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.inc_var_f
+                """
+        }
+        Opcode.POP_INC_MEMORY -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
++               inc  65535     ; modified
+                """
+        }
+        Opcode.POP_DEC_MEMORY -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
++               dec  65535     ; modified
+                """
+        }
+        Opcode.DEC_VAR_UB, Opcode.DEC_VAR_B -> {
+            when (ins.callLabel) {
+                "A" -> " sec |  sbc  #1"
+                "X" -> " dex"
+                "Y" -> " dey"
+                else -> " dec  ${ins.callLabel}"
+            }
+        }
+        Opcode.DEC_VAR_UW, Opcode.DEC_VAR_W -> {
+            " lda  ${ins.callLabel} |  bne  + |  dec  ${ins.callLabel}+1 |+ |  dec  ${ins.callLabel}"
+        }
+        Opcode.DEC_VAR_F -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.dec_var_f
+                """
+        }
+        Opcode.INC_MEMORY -> " inc  ${hexVal(ins)}"
+        Opcode.DEC_MEMORY -> " dec  ${hexVal(ins)}"
+        Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB -> " inx |  txa |  pha |  lda  $ESTACK_LO_HEX,x |  tax |  inc  ${ins.callLabel},x |  pla |  tax"
+        Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB -> " inx |  txa |  pha |  lda  $ESTACK_LO_HEX,x |  tax |  dec  ${ins.callLabel},x |  pla |  tax"
+
+        Opcode.NEG_B -> " jsr  prog8_lib.neg_b"
+        Opcode.NEG_W -> " jsr  prog8_lib.neg_w"
+        Opcode.NEG_F -> " jsr  c64flt.neg_f"
+        Opcode.ABS_B -> " jsr  prog8_lib.abs_b"
+        Opcode.ABS_W -> " jsr  prog8_lib.abs_w"
+        Opcode.ABS_F -> " jsr  c64flt.abs_f"
+        Opcode.POW_F -> " jsr  c64flt.pow_f"
+        Opcode.INV_BYTE -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                eor  #255
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.INV_WORD -> " jsr  prog8_lib.inv_word"
+        Opcode.NOT_BYTE -> " jsr  prog8_lib.not_byte"
+        Opcode.NOT_WORD -> " jsr  prog8_lib.not_word"
+        Opcode.BCS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bcs  $label"
+        }
+        Opcode.BCC -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bcc  $label"
+        }
+        Opcode.BNEG -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bmi  $label"
+        }
+        Opcode.BPOS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bpl  $label"
+        }
+        Opcode.BVC -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bvc  $label"
+        }
+        Opcode.BVS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bvs  $label"
+        }
+        Opcode.BZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " beq  $label"
+        }
+        Opcode.BNZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bne  $label"
+        }
+        Opcode.JZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                beq  $label
+                """
+        }
+        Opcode.JZW -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                beq  $label
+                lda  $ESTACK_HI_HEX,x
+                beq  $label
+                """
+        }
+        Opcode.JNZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  $label
+                """
+        }
+        Opcode.JNZW -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  $label
+                lda  $ESTACK_HI_HEX,x
+                bne  $label
+                """
+        }
+        Opcode.CAST_B_TO_UB -> ""  // is a no-op, just carry on with the byte as-is
+        Opcode.CAST_UB_TO_B -> ""  // is a no-op, just carry on with the byte as-is
+        Opcode.CAST_W_TO_UW -> ""  // is a no-op, just carry on with the word as-is
+        Opcode.CAST_UW_TO_W -> ""  // is a no-op, just carry on with the word as-is
+        Opcode.CAST_W_TO_UB -> ""  // is a no-op, just carry on with the lsb of the word as-is
+        Opcode.CAST_W_TO_B -> ""  // is a no-op, just carry on with the lsb of the word as-is
+        Opcode.CAST_UW_TO_UB -> ""  // is a no-op, just carry on with the lsb of the uword as-is
+        Opcode.CAST_UW_TO_B -> ""  // is a no-op, just carry on with the lsb of the uword as-is
+        Opcode.CAST_UB_TO_F -> " jsr  c64flt.stack_ub2float"
+        Opcode.CAST_B_TO_F -> " jsr  c64flt.stack_b2float"
+        Opcode.CAST_UW_TO_F -> " jsr  c64flt.stack_uw2float"
+        Opcode.CAST_W_TO_F -> " jsr  c64flt.stack_w2float"
+        Opcode.CAST_F_TO_UB -> " jsr  c64flt.stack_float2ub"
+        Opcode.CAST_F_TO_B -> " jsr  c64flt.stack_float2b"
+        Opcode.CAST_F_TO_UW -> " jsr  c64flt.stack_float2uw"
+        Opcode.CAST_F_TO_W -> " jsr  c64flt.stack_float2w"
+        Opcode.CAST_UB_TO_UW, Opcode.CAST_UB_TO_W -> " lda  #0 |  sta  $ESTACK_HI_PLUS1_HEX,x"     // clear the msb
+        Opcode.CAST_B_TO_UW, Opcode.CAST_B_TO_W -> " lda  $ESTACK_LO_PLUS1_HEX,x |  ${signExtendA("$ESTACK_HI_PLUS1_HEX,x")}"     // sign extend the lsb
+        Opcode.MSB -> " lda  $ESTACK_HI_PLUS1_HEX,x |  sta  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.MKWORD -> " inx |  lda  $ESTACK_LO_HEX,x |  sta  $ESTACK_HI_PLUS1_HEX,x "
+
+        Opcode.ADD_UB, Opcode.ADD_B -> {        // TODO inline better (pattern with more opcodes)
+            """
+                lda  $ESTACK_LO_PLUS2_HEX,x
+                clc
+                adc  $ESTACK_LO_PLUS1_HEX,x
+                inx
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.SUB_UB, Opcode.SUB_B -> {        // TODO inline better (pattern with more opcodes)
+            """
+                lda  $ESTACK_LO_PLUS2_HEX,x
+                sec
+                sbc  $ESTACK_LO_PLUS1_HEX,x
+                inx
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.ADD_W, Opcode.ADD_UW -> "  jsr  prog8_lib.add_w"
+        Opcode.SUB_W, Opcode.SUB_UW -> "  jsr  prog8_lib.sub_w"
+        Opcode.MUL_B, Opcode.MUL_UB -> "  jsr  prog8_lib.mul_byte"
+        Opcode.MUL_W, Opcode.MUL_UW -> "  jsr  prog8_lib.mul_word"
+        Opcode.MUL_F -> "  jsr  c64flt.mul_f"
+        Opcode.ADD_F -> "  jsr  c64flt.add_f"
+        Opcode.SUB_F -> "  jsr  c64flt.sub_f"
+        Opcode.DIV_F -> "  jsr  c64flt.div_f"
+        Opcode.IDIV_UB -> "  jsr  prog8_lib.idiv_ub"
+        Opcode.IDIV_B -> "  jsr  prog8_lib.idiv_b"
+        Opcode.IDIV_W -> "  jsr  prog8_lib.idiv_w"
+        Opcode.IDIV_UW -> "  jsr  prog8_lib.idiv_uw"
+
+        Opcode.AND_BYTE -> "  jsr  prog8_lib.and_b"
+        Opcode.OR_BYTE -> "  jsr  prog8_lib.or_b"
+        Opcode.XOR_BYTE -> "  jsr  prog8_lib.xor_b"
+        Opcode.AND_WORD -> "  jsr  prog8_lib.and_w"
+        Opcode.OR_WORD -> "  jsr  prog8_lib.or_w"
+        Opcode.XOR_WORD -> "  jsr  prog8_lib.xor_w"
+
+        Opcode.BITAND_BYTE -> "  jsr  prog8_lib.bitand_b"
+        Opcode.BITOR_BYTE -> "  jsr  prog8_lib.bitor_b"
+        Opcode.BITXOR_BYTE -> "  jsr  prog8_lib.bitxor_b"
+        Opcode.BITAND_WORD -> "  jsr  prog8_lib.bitand_w"
+        Opcode.BITOR_WORD -> "  jsr  prog8_lib.bitor_w"
+        Opcode.BITXOR_WORD -> "  jsr  prog8_lib.bitxor_w"
+
+        Opcode.REMAINDER_UB -> "  jsr  prog8_lib.remainder_ub"
+        Opcode.REMAINDER_UW -> "  jsr  prog8_lib.remainder_uw"
+
+        Opcode.GREATER_B -> "  jsr  prog8_lib.greater_b"
+        Opcode.GREATER_UB -> "  jsr  prog8_lib.greater_ub"
+        Opcode.GREATER_W -> "  jsr  prog8_lib.greater_w"
+        Opcode.GREATER_UW -> "  jsr  prog8_lib.greater_uw"
+        Opcode.GREATER_F -> "  jsr  c64flt.greater_f"
+
+        Opcode.GREATEREQ_B -> "  jsr  prog8_lib.greatereq_b"
+        Opcode.GREATEREQ_UB -> "  jsr  prog8_lib.greatereq_ub"
+        Opcode.GREATEREQ_W -> "  jsr  prog8_lib.greatereq_w"
+        Opcode.GREATEREQ_UW -> "  jsr  prog8_lib.greatereq_uw"
+        Opcode.GREATEREQ_F -> "  jsr  c64flt.greatereq_f"
+
+        Opcode.EQUAL_BYTE -> "  jsr  prog8_lib.equal_b"
+        Opcode.EQUAL_WORD -> "  jsr  prog8_lib.equal_w"
+        Opcode.EQUAL_F -> "  jsr  c64flt.equal_f"
+        Opcode.NOTEQUAL_BYTE -> "  jsr prog8_lib.notequal_b"
+        Opcode.NOTEQUAL_WORD -> "  jsr prog8_lib.notequal_w"
+        Opcode.NOTEQUAL_F -> "  jsr  c64flt.notequal_f"
+
+        Opcode.LESS_UB -> "  jsr  prog8_lib.less_ub"
+        Opcode.LESS_B -> "  jsr  prog8_lib.less_b"
+        Opcode.LESS_UW -> "  jsr  prog8_lib.less_uw"
+        Opcode.LESS_W -> "  jsr  prog8_lib.less_w"
+        Opcode.LESS_F -> "  jsr  c64flt.less_f"
+
+        Opcode.LESSEQ_UB -> "  jsr  prog8_lib.lesseq_ub"
+        Opcode.LESSEQ_B -> "  jsr  prog8_lib.lesseq_b"
+        Opcode.LESSEQ_UW -> "  jsr  prog8_lib.lesseq_uw"
+        Opcode.LESSEQ_W -> "  jsr  prog8_lib.lesseq_w"
+        Opcode.LESSEQ_F -> "  jsr  c64flt.lesseq_f"
+
+        Opcode.SHIFTEDL_BYTE -> "  asl  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDL_WORD -> "  asl  $ESTACK_LO_PLUS1_HEX,x |  rol  $ESTACK_HI_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_SBYTE -> "  lda  $ESTACK_LO_PLUS1_HEX,x |  asl  a |  ror  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_UBYTE -> "  lsr  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_SWORD -> "  lda  $ESTACK_HI_PLUS1_HEX,x |  asl a  |  ror  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_UWORD -> "  lsr  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x"
+
+        else -> null
+    }
+}

DeprecatedStackVm/src/prog8/vm/stackvm/Main.kt

@@ -1,6 +1,7 @@
-package prog8
+package prog8.vm.stackvm
 
-import prog8.stackvm.*
+import prog8.printSoftwareHeader
+import prog8.vm.astvm.ScreenDialog
 import java.awt.EventQueue
 import javax.swing.Timer
 import kotlin.system.exitProcess
@@ -19,7 +20,7 @@ fun stackVmMain(args: Array<String>) {
 
     val program = Program.load(args.first())
     val vm = StackVm(traceOutputFile = null)
-    val dialog = ScreenDialog()
+    val dialog = ScreenDialog("StackVM")
     vm.load(program, dialog.canvas)
     EventQueue.invokeLater {
         dialog.pack()

DeprecatedStackVm/src/prog8/vm/stackvm/Program.kt

@@ -1,19 +1,26 @@
-package prog8.stackvm
+package prog8.vm.stackvm
 
-import prog8.ast.*
+import prog8.ast.antlr.unescape
+import prog8.ast.base.*
+import prog8.ast.expressions.AddressOf
+import prog8.ast.expressions.IdentifierReference
 import prog8.compiler.HeapValues
 import prog8.compiler.IntegerOrAddressOf
-import prog8.compiler.intermediate.*
+import prog8.compiler.intermediate.Instruction
+import prog8.compiler.intermediate.LabelInstr
+import prog8.compiler.intermediate.Opcode
+import prog8.compiler.intermediate.opcodesWithVarArgument
+import prog8.vm.RuntimeValue
 import java.io.File
 import java.util.*
 import java.util.regex.Pattern
 
 class Program (val name: String,
                val program: MutableList<Instruction>,
-               val variables: Map<String, Value>,
+               val variables: Map<String, RuntimeValue>,
                val memoryPointers: Map<String, Pair<Int, DataType>>,
                val labels: Map<String, Int>,
-               val memory: Map<Int, List<Value>>,
+               val memory: Map<Int, List<RuntimeValue>>,
                val heap: HeapValues)
 {
     init {
@@ -26,10 +33,10 @@ class Program (val name: String,
     companion object {
         fun load(filename: String): Program {
             val lines = File(filename).readLines().withIndex().iterator()
-            val memory = mutableMapOf<Int, List<Value>>()
+            val memory = mutableMapOf<Int, List<RuntimeValue>>()
             val heap = HeapValues()
             val program = mutableListOf<Instruction>()
-            val variables = mutableMapOf<String, Value>()
+            val variables = mutableMapOf<String, RuntimeValue>()
             val memoryPointers = mutableMapOf<String, Pair<Int, DataType>>()
             val labels = mutableMapOf<String, Int>()
 
@@ -51,7 +58,7 @@ class Program (val name: String,
         private fun loadBlock(lines: Iterator<IndexedValue<String>>,
                               heap: HeapValues,
                               program: MutableList<Instruction>,
-                              variables: MutableMap<String, Value>,
+                              variables: MutableMap<String, RuntimeValue>,
                               memoryPointers: MutableMap<String, Pair<Int, DataType>>,
                               labels: MutableMap<String, Int>)
         {
@@ -88,7 +95,7 @@ class Program (val name: String,
             }
             heapvalues.sortedBy { it.first }.forEach {
                 when(it.second) {
-                    DataType.STR, DataType.STR_S -> heap.addString(it.second, unescape(it.third.substring(1, it.third.length-1), Position("<stackvmsource>", 0, 0, 0)))
+                    DataType.STR, DataType.STR_S -> heap.addString(it.second, unescape(it.third.substring(1, it.third.length - 1), Position("<stackvmsource>", 0, 0, 0)))
                     DataType.ARRAY_UB, DataType.ARRAY_B,
                     DataType.ARRAY_UW, DataType.ARRAY_W -> {
                         val numbers = it.third.substring(1, it.third.length-1).split(',')
@@ -97,8 +104,8 @@ class Program (val name: String,
                             if(num.startsWith("&")) {
                                 // it's AddressOf
                                 val scopedname = num.substring(1)
-                                val iref = IdentifierReference(scopedname.split('.'), Position("<intermediate>", 0,0,0))
-                                val addrOf = AddressOf(iref, Position("<intermediate>", 0,0,0))
+                                val iref = IdentifierReference(scopedname.split('.'), Position("<intermediate>", 0, 0, 0))
+                                val addrOf = AddressOf(iref, Position("<intermediate>", 0, 0, 0))
                                 addrOf.scopedname=scopedname
                                 IntegerOrAddressOf(null, addrOf)
                             } else {
@@ -122,7 +129,7 @@ class Program (val name: String,
             val instructions = mutableListOf<Instruction>()
             val labels = mutableMapOf<String, Instruction>()
             val splitpattern = Pattern.compile("\\s+")
-            val nextInstructionLabels = Stack<String>()     // more than one label can occur on the same line
+            val nextInstructionLabels = Stack<String>()     // more than one label can occur on the isSameAs line
 
             while(true) {
                 val (lineNr, line) = lines.next()
@@ -143,7 +150,7 @@ class Program (val name: String,
                         Opcode.BZ, Opcode.BNZ, Opcode.BCS, Opcode.BCC,
                         Opcode.JZ, Opcode.JNZ, Opcode.JZW, Opcode.JNZW -> {
                             if(args!!.startsWith('$')) {
-                                Instruction(opcode, Value(DataType.UWORD, args.substring(1).toInt(16)))
+                                Instruction(opcode, RuntimeValue(DataType.UWORD, args.substring(1).toInt(16)))
                             } else {
                                 Instruction(opcode, callLabel = args)
                             }
@@ -158,15 +165,15 @@ class Program (val name: String,
                         Opcode.SYSCALL -> {
                             if(args!! in syscallNames) {
                                 val call = Syscall.valueOf(args)
-                                Instruction(opcode, Value(DataType.UBYTE, call.callNr))
+                                Instruction(opcode, RuntimeValue(DataType.UBYTE, call.callNr))
                             } else {
                                 val args2 = args.replace('.', '_')
                                 if(args2 in syscallNames) {
                                     val call = Syscall.valueOf(args2)
-                                    Instruction(opcode, Value(DataType.UBYTE, call.callNr))
+                                    Instruction(opcode, RuntimeValue(DataType.UBYTE, call.callNr))
                                 } else {
                                     // the syscall is not yet implemented. emit a stub.
-                                    Instruction(Opcode.SYSCALL, Value(DataType.UBYTE, Syscall.SYSCALLSTUB.callNr), callLabel = args2)
+                                    Instruction(Opcode.SYSCALL, RuntimeValue(DataType.UBYTE, Syscall.SYSCALLSTUB.callNr), callLabel = args2)
                                 }
                             }
                         }
@@ -190,7 +197,7 @@ class Program (val name: String,
             }
         }
 
-        private fun getArgValue(args: String?, heap: HeapValues): Value? {
+        private fun getArgValue(args: String?, heap: HeapValues): RuntimeValue? {
             if(args==null)
                 return null
             if(args[0]=='"' && args[args.length-1]=='"') {
@@ -198,21 +205,21 @@ class Program (val name: String,
             }
             val (type, valueStr) = args.split(':')
             return when(type) {
-                "b" -> Value(DataType.BYTE, valueStr.toShort(16))
-                "ub" -> Value(DataType.UBYTE, valueStr.toShort(16))
-                "w" -> Value(DataType.WORD, valueStr.toInt(16))
-                "uw" -> Value(DataType.UWORD, valueStr.toInt(16))
-                "f" -> Value(DataType.FLOAT, valueStr.toDouble())
+                "b" -> RuntimeValue(DataType.BYTE, valueStr.toShort(16))
+                "ub" -> RuntimeValue(DataType.UBYTE, valueStr.toShort(16))
+                "w" -> RuntimeValue(DataType.WORD, valueStr.toInt(16))
+                "uw" -> RuntimeValue(DataType.UWORD, valueStr.toInt(16))
+                "f" -> RuntimeValue(DataType.FLOAT, valueStr.toDouble())
                 "heap" -> {
                     val heapId = valueStr.toInt()
-                    Value(heap.get(heapId).type, heapId)
+                    RuntimeValue(heap.get(heapId).type, heapId = heapId)
                 }
                 else -> throw VmExecutionException("invalid datatype $type")
             }
         }
 
         private fun loadVars(lines: Iterator<IndexedValue<String>>,
-                             vars: MutableMap<String, Value>) {
+                             vars: MutableMap<String, RuntimeValue>) {
             val splitpattern = Pattern.compile("\\s+")
             while(true) {
                 val (_, line) = lines.next()
@@ -221,29 +228,28 @@ class Program (val name: String,
                 val (name, typeStr, valueStr) = line.split(splitpattern, limit = 3)
                 if(valueStr[0] !='"' && ':' !in valueStr)
                     throw VmExecutionException("missing value type character")
-                val type = DataType.valueOf(typeStr.toUpperCase())
-                val value = when(type) {
-                    DataType.UBYTE -> Value(DataType.UBYTE, valueStr.substring(3).toShort(16))
-                    DataType.BYTE -> Value(DataType.BYTE, valueStr.substring(2).toShort(16))
-                    DataType.UWORD -> Value(DataType.UWORD, valueStr.substring(3).toInt(16))
-                    DataType.WORD -> Value(DataType.WORD, valueStr.substring(2).toInt(16))
-                    DataType.FLOAT -> Value(DataType.FLOAT, valueStr.substring(2).toDouble())
+                val value = when(val type = DataType.valueOf(typeStr.toUpperCase())) {
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, valueStr.substring(3).substringBefore(' ').toShort(16))// TODO process ZP and struct info?
+                    DataType.BYTE -> RuntimeValue(DataType.BYTE, valueStr.substring(2).substringBefore(' ').toShort(16))// TODO process ZP and struct info?
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, valueStr.substring(3).substringBefore(' ').toInt(16))// TODO process ZP and struct info?
+                    DataType.WORD -> RuntimeValue(DataType.WORD, valueStr.substring(2).substringBefore(' ').toInt(16))// TODO process ZP and struct info?
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, valueStr.substring(2).substringBefore(' ').toDouble())// TODO process ZP and struct info?
                     in StringDatatypes -> {
                         if(valueStr.startsWith('"') && valueStr.endsWith('"'))
                             throw VmExecutionException("encountered a var with a string value, but all string values should already have been moved into the heap")
                         else if(!valueStr.startsWith("heap:"))
                             throw VmExecutionException("invalid string value, should be a heap reference")
                         else {
-                            val heapId = valueStr.substring(5).toInt()
-                            Value(type, heapId)
+                            val heapId = valueStr.substring(5).substringBefore(' ').toInt()     // TODO process ZP and struct info?
+                            RuntimeValue(type, heapId = heapId)
                         }
                     }
                     in ArrayDatatypes -> {
                         if(!valueStr.startsWith("heap:"))
                             throw VmExecutionException("invalid array value, should be a heap reference")
                         else {
-                            val heapId = valueStr.substring(5).toInt()
-                            Value(type, heapId)
+                            val heapId = valueStr.substring(5).substringBefore(' ').toInt()     // TODO process ZP and struct info?
+                            RuntimeValue(type, heapId = heapId)
                         }
                     }
                     else -> throw VmExecutionException("weird datatype")
@@ -269,7 +275,7 @@ class Program (val name: String,
             }
         }
 
-        private fun loadMemory(lines: Iterator<IndexedValue<String>>, memory: MutableMap<Int, List<Value>>): Map<Int, List<Value>> {
+        private fun loadMemory(lines: Iterator<IndexedValue<String>>, memory: MutableMap<Int, List<RuntimeValue>>): Map<Int, List<RuntimeValue>> {
             while(true) {
                 val (lineNr, line) = lines.next()
                 if(line=="%end_memory")
@@ -280,11 +286,11 @@ class Program (val name: String,
                     TODO("memory init with char/string")
                 } else {
                     val valueStrings = rest.split(' ')
-                    val values = mutableListOf<Value>()
+                    val values = mutableListOf<RuntimeValue>()
                     valueStrings.forEach {
                         when(it.length) {
-                            2 -> values.add(Value(DataType.UBYTE, it.toShort(16)))
-                            4 -> values.add(Value(DataType.UWORD, it.toInt(16)))
+                            2 -> values.add(RuntimeValue(DataType.UBYTE, it.toShort(16)))
+                            4 -> values.add(RuntimeValue(DataType.UWORD, it.toInt(16)))
                             else -> throw VmExecutionException("invalid value at line $lineNr+1")
                         }
                     }

README.md

@@ -1,3 +1,6 @@
+[![saythanks](https://img.shields.io/badge/say-thanks-ff69b4.svg)](https://saythanks.io/to/irmen)
+[![Build Status](https://travis-ci.org/irmen/prog8.svg?branch=master)](https://travis-ci.org/irmen/prog8)
+
 Prog8 - Structured Programming Language for 8-bit 6502/6510 microprocessors
 ===========================================================================
 
@@ -11,36 +14,50 @@ as used in many home computers from that era. It is a medium to low level progra
 which aims to provide many conveniences over raw assembly code (even when using a macro assembler):
 
 - reduction of source code length
-- easier program understanding (because it's higher level, and more terse)
-- option to automatically run the compiled program in the Vice emulator  
+- easier program understanding (because it's higher level, and way more compact)
 - modularity, symbol scoping, subroutines
 - subroutines have enforced input- and output parameter definitions
-- various data types other than just bytes (16-bit words, floats, strings, 16-bit register pairs)
+- various data types other than just bytes (16-bit words, floats, strings)
 - automatic variable allocations, automatic string variables and string sharing
 - constant folding in expressions (compile-time evaluation)
+- conditional branches
+- when statement to provide a 'jump table' alternative to if/elseif chains
+- structs to group together sets of variables and manipulate them at once
 - automatic type conversions
-- floating point operations
+- floating point operations  (uses the C64 Basic ROM routines for this)
 - abstracting away low level aspects such as ZeroPage handling, program startup, explicit memory addresses
+- various code optimizations (code structure, logical and numerical expressions, unused code removal...)
+- inline assembly allows you to have full control when every cycle or byte matters
+ 
+
+Rapid edit-compile-run-debug cycle:
+
+- use modern PC to work on 
+- quick compilation times (around a second, and less than 0.1 seconds when using the continuous compilation mode)
+- option to automatically run the program in the Vice emulator  
 - breakpoints, that let the Vice emulator drop into the monitor if execution hits them
 - source code labels automatically loaded in Vice emulator so it can show them in disassembly
-- conditional gotos
-- various code optimizations (code structure, logical and numerical expressions, ...) 
-
+- the compiler includes a virtual machine that can execute compiled code directy on the
+  host system without having to actually convert it to assembly to run on a real 6502. 
+  This allows for very quick experimentation and debugging
 
 It is mainly targeted at the Commodore-64 machine at this time.
+Contributions to add support for other 8-bit (or other?!) machines are welcome.
 
-Documentation is online at https://prog8.readthedocs.io/
+Documentation/manual
+--------------------
+See https://prog8.readthedocs.io/
 
 
-Required tools:
----------------
+Required tools
+--------------
 
 [64tass](https://sourceforge.net/projects/tass64/) - cross assembler. Install this on your shell path.
 A recent .exe version of this tool for Windows can be obtained from my [clone](https://github.com/irmen/64tass/releases) of this project.
 For other platforms it is very easy to compile it yourself (make ; make install).
 
-A **Java runtime (jre or jdk), version 8 or newer**  is required to run the packaged compiler.
-If you want to build it from source, you'll need a Kotlin 1.3 SDK as well (or for instance,
+A **Java runtime (jre or jdk), version 8 or newer**  is required to run a prepackaged version of the compiler.
+If you want to build it from source, you'll need a Java SDK + Kotlin 1.3.x SDK (or for instance,
 IntelliJ IDEA with the Kotlin plugin).
 
 It's handy to have a C-64 emulator or a real C-64 to run the programs on. The compiler assumes the presence
@@ -55,7 +72,7 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
     %import c64utils
     %zeropage basicsafe
 
-    ~ main {
+    main {
 
         ubyte[256] sieve
         ubyte candidate_prime = 2

compiler/build.gradle

@@ -1,20 +1,36 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm" version "1.3.30"
-    id 'application'
+buildscript {
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
 }
 
+plugins {
+    // id "org.jetbrains.kotlin.jvm" version $kotlinVersion
+    id 'application'
+    id 'org.jetbrains.dokka' version "0.9.18"
+    id 'com.github.johnrengelman.shadow' version '5.1.0'
+    id 'java'
+}
+
+apply plugin: "kotlin"
+apply plugin: "java"
+
+
 repositories {
+    mavenLocal()
     mavenCentral()
     jcenter()
 }
 
-def kotlinVersion = '1.3.30'
+sourceCompatibility = 1.8
+
+def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
 
 dependencies {
     implementation project(':parser')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
-    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
-    runtime "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+    // implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+    // runtime "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
     runtime 'org.antlr:antlr4-runtime:4.7.2'
     runtime project(':parser')
 
@@ -28,6 +44,8 @@ dependencies {
 compileKotlin {
     kotlinOptions {
         jvmTarget = "1.8"
+        verbose = true
+        // freeCompilerArgs += "-XXLanguage:+NewInference"
     }
 }
 
@@ -47,41 +65,27 @@ sourceSets {
     }
 }
 
-
+startScripts.enabled = true
 
 application {
     mainClassName = 'prog8.CompilerMainKt'
     applicationName = 'p8compile'
 }
 
-task p8vmScript(type: CreateStartScripts) {
-    mainClassName = "prog8.StackVmMainKt"
-    applicationName = "p8vm"
-    outputDir = new File(project.buildDir, 'scripts')
-    classpath = jar.outputs.files + project.configurations.runtime
+artifacts {
+    archives shadowJar
 }
 
-applicationDistribution.into("bin") {
-    from(p8vmScript)
-    fileMode = 0755
+
+// To create a fat-jar use the 'create_compiler_jar' script for now
+// @todo investigate https://imperceptiblethoughts.com/shadow/introduction/
+
+shadowJar {
+    baseName = 'prog8compiler'
+    version = prog8version
+    // minimize()
 }
 
-task fatJar(type: Jar) {
-    manifest {
-        attributes 'Main-Class': 'prog8.CompilerMainKt'
-    }
-    archiveBaseName = 'prog8compiler'
-    destinationDirectory = rootProject.projectDir
-    from {
-        project.configurations.runtime.collect { it.isDirectory() ? it : zipTree(it) }
-    }
-    with jar
-}
-// build.finalizedBy(fatJar)
-
-
-// Java target version
-sourceCompatibility = 1.8
 
 test {
     // Enable JUnit 5 (Gradle 4.6+).
@@ -95,3 +99,9 @@ test {
         events "passed", "skipped", "failed"
     }
 }
+
+
+dokka {
+    outputFormat = 'html'
+    outputDirectory = "$buildDir/kdoc"
+}

compiler/compiler.iml

@@ -0,0 +1,18 @@
+<?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$/res" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+    </content>
+    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+    <orderEntry type="library" name="antlr-runtime-4.7.2" level="project" />
+    <orderEntry type="module" module-name="parser" />
+    <orderEntry type="library" name="unittest-libs" level="project" />
+  </component>
+</module>

compiler/res/prog8lib/c64flt.p8

@@ -7,7 +7,7 @@
 %option enable_floats
 
 
-~ c64flt {
+c64flt {
 	; ---- this block contains C-64 floating point related functions ----
 
 		const  float  PI	= 3.141592653589793
@@ -41,25 +41,25 @@
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
 ; checked functions below:
-asmsub	MOVFM		(uword mflpt @ AY) -> clobbers(A,Y) -> ()	= $bba2		; load mflpt value from memory  in A/Y into fac1
-asmsub	FREADMEM	() -> clobbers(A,Y) -> ()			= $bba6		; load mflpt value from memory  in $22/$23 into fac1
-asmsub	CONUPK		(uword mflpt @ AY) -> clobbers(A,Y) -> ()	= $ba8c		; load mflpt value from memory  in A/Y into fac2
-asmsub	FAREADMEM	() -> clobbers(A,Y) -> ()			= $ba90		; load mflpt value from memory  in $22/$23 into fac2
-asmsub	MOVFA		() -> clobbers(A,X) -> ()			= $bbfc		; copy fac2 to fac1
-asmsub	MOVAF		() -> clobbers(A,X) -> ()			= $bc0c		; copy fac1 to fac2  (rounded)
-asmsub	MOVEF		() -> clobbers(A,X) -> ()			= $bc0f		; copy fac1 to fac2
-asmsub	MOVMF		(uword mflpt @ XY) -> clobbers(A,Y) -> ()	= $bbd4		; store fac1 to memory  X/Y as 5-byte mflpt
+asmsub	MOVFM		(uword mflpt @ AY) clobbers(A,Y)	= $bba2		; load mflpt value from memory  in A/Y into fac1
+asmsub	FREADMEM	() clobbers(A,Y)			= $bba6		; load mflpt value from memory  in $22/$23 into fac1
+asmsub	CONUPK		(uword mflpt @ AY) clobbers(A,Y)	= $ba8c		; load mflpt value from memory  in A/Y into fac2
+asmsub	FAREADMEM	() clobbers(A,Y)			= $ba90		; load mflpt value from memory  in $22/$23 into fac2
+asmsub	MOVFA		() clobbers(A,X)			= $bbfc		; copy fac2 to fac1
+asmsub	MOVAF		() clobbers(A,X)			= $bc0c		; copy fac1 to fac2  (rounded)
+asmsub	MOVEF		() clobbers(A,X)			= $bc0f		; copy fac1 to fac2
+asmsub	MOVMF		(uword mflpt @ XY) clobbers(A,Y)	= $bbd4		; store fac1 to memory  X/Y as 5-byte mflpt
 
 ; fac1-> signed word in Y/A (might throw ILLEGAL QUANTITY)
 ; (tip: use c64flt.FTOSWRDAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	FTOSWORDYA	() -> clobbers(X) -> (ubyte @ Y, ubyte @ A)	= $b1aa
+asmsub	FTOSWORDYA	() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b1aa     ; note: calls AYINT.
 
 ; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
 ; (tip: use c64flt.GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	GETADR		() -> clobbers(X) -> (ubyte @ Y, ubyte @ A)	= $b7f7
+asmsub	GETADR		() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b7f7
 
-asmsub	QINT		() -> clobbers(A,X,Y) -> ()			= $bc9b		; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
-asmsub	AYINT		() -> clobbers(A,X,Y) -> ()			= $b1bf		; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
+asmsub	QINT		() clobbers(A,X,Y)			= $bc9b		; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
+asmsub	AYINT		() clobbers(A,X,Y)			= $b1bf		; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
 ; (tip: use c64flt.GIVAYFAY to use A/Y input; lo/hi switched to normal order)
@@ -67,50 +67,50 @@ asmsub	AYINT		() -> clobbers(A,X,Y) -> ()			= $b1bf		; fac1-> signed word in 100
 ; there is also c64flt.FREADS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADUS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADS24AXY  that reads signed int24 into fac1 from A/X/Y (lo/mid/hi bytes)
-asmsub	GIVAYF		(ubyte lo @ Y, ubyte hi @ A) -> clobbers(A,X,Y) -> ()	= $b391
+asmsub	GIVAYF		(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)	= $b391
 
-asmsub	FREADUY		(ubyte value @ Y) -> clobbers(A,X,Y) -> ()	= $b3a2		; 8 bit unsigned Y -> float in fac1
-asmsub	FREADSA		(byte value @ A) -> clobbers(A,X,Y) -> ()	= $bc3c		; 8 bit signed A -> float in fac1
-asmsub	FREADSTR	(ubyte length @ A) -> clobbers(A,X,Y) -> ()	= $b7b5		; str -> fac1, $22/23 must point to string, A=string length
-asmsub	FPRINTLN	() -> clobbers(A,X,Y) -> ()			= $aabc		; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
-asmsub	FOUT		() -> clobbers(X) -> (uword @ AY)		= $bddd		; fac1 -> string, address returned in AY ($0100)
+asmsub	FREADUY		(ubyte value @ Y) clobbers(A,X,Y)	= $b3a2		; 8 bit unsigned Y -> float in fac1
+asmsub	FREADSA		(byte value @ A) clobbers(A,X,Y)	= $bc3c		; 8 bit signed A -> float in fac1
+asmsub	FREADSTR	(ubyte length @ A) clobbers(A,X,Y)	= $b7b5		; str -> fac1, $22/23 must point to string, A=string length
+asmsub	FPRINTLN	() clobbers(A,X,Y)			= $aabc		; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
+asmsub	FOUT		() clobbers(X) -> uword @ AY		= $bddd		; fac1 -> string, address returned in AY ($0100)
 
-asmsub	FADDH		() -> clobbers(A,X,Y) -> ()			= $b849		; fac1 += 0.5, for rounding- call this before INT
-asmsub	MUL10		() -> clobbers(A,X,Y) -> ()			= $bae2		; fac1 *= 10
-asmsub	DIV10		() -> clobbers(A,X,Y) -> ()			= $bafe		; fac1 /= 10 , CAUTION: result is always positive!
-asmsub	FCOMP		(uword mflpt @ AY) -> clobbers(X,Y) -> (ubyte @ A) = $bc5b		; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
+asmsub	FADDH		() clobbers(A,X,Y)			= $b849		; fac1 += 0.5, for rounding- call this before INT
+asmsub	MUL10		() clobbers(A,X,Y)			= $bae2		; fac1 *= 10
+asmsub	DIV10		() clobbers(A,X,Y)			= $bafe		; fac1 /= 10 , CAUTION: result is always positive!
+asmsub	FCOMP		(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A = $bc5b		; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
 
-asmsub	FADDT		() -> clobbers(A,X,Y) -> ()			= $b86a		; fac1 += fac2
-asmsub	FADD		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $b867		; fac1 += mflpt value from A/Y
-asmsub	FSUBT		() -> clobbers(A,X,Y) -> ()			= $b853		; fac1 = fac2-fac1   mind the order of the operands
-asmsub	FSUB		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $b850		; fac1 = mflpt from A/Y - fac1
-asmsub	FMULTT 		() -> clobbers(A,X,Y) -> ()			= $ba2b		; fac1 *= fac2
-asmsub	FMULT		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $ba28		; fac1 *= mflpt value from A/Y
-asmsub	FDIVT 		() -> clobbers(A,X,Y) -> ()			= $bb12		; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
-asmsub	FDIV  		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $bb0f		; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
-asmsub	FPWRT		() -> clobbers(A,X,Y) -> ()			= $bf7b		; fac1 = fac2 ** fac1
-asmsub	FPWR		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $bf78		; fac1 = fac2 ** mflpt from A/Y
+asmsub	FADDT		() clobbers(A,X,Y)			= $b86a		; fac1 += fac2
+asmsub	FADD		(uword mflpt @ AY) clobbers(A,X,Y)	= $b867		; fac1 += mflpt value from A/Y
+asmsub	FSUBT		() clobbers(A,X,Y)			= $b853		; fac1 = fac2-fac1   mind the order of the operands
+asmsub	FSUB		(uword mflpt @ AY) clobbers(A,X,Y)	= $b850		; fac1 = mflpt from A/Y - fac1
+asmsub	FMULTT 		() clobbers(A,X,Y)			= $ba2b		; fac1 *= fac2
+asmsub	FMULT		(uword mflpt @ AY) clobbers(A,X,Y)	= $ba28		; fac1 *= mflpt value from A/Y
+asmsub	FDIVT 		() clobbers(A,X,Y)			= $bb12		; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
+asmsub	FDIV  		(uword mflpt @ AY) clobbers(A,X,Y)	= $bb0f		; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
+asmsub	FPWRT		() clobbers(A,X,Y)			= $bf7b		; fac1 = fac2 ** fac1
+asmsub	FPWR		(uword mflpt @ AY) clobbers(A,X,Y)	= $bf78		; fac1 = fac2 ** mflpt from A/Y
 
-asmsub	NOTOP		() -> clobbers(A,X,Y) -> ()			= $aed4		; fac1 = NOT(fac1)
-asmsub	INT		() -> clobbers(A,X,Y) -> ()			= $bccc		; INT() truncates, use FADDH first to round instead of trunc
-asmsub	LOG		() -> clobbers(A,X,Y) -> ()			= $b9ea		; fac1 = LN(fac1)  (natural log)
-asmsub	SGN		() -> clobbers(A,X,Y) -> ()			= $bc39		; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
-asmsub	SIGN		() -> clobbers() -> (ubyte @ A)			= $bc2b		; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
-asmsub	ABS		() -> clobbers() -> ()				= $bc58		; fac1 = ABS(fac1)
-asmsub	SQR		() -> clobbers(A,X,Y) -> ()			= $bf71		; fac1 = SQRT(fac1)
-asmsub	SQRA		() -> clobbers(A,X,Y) -> ()			= $bf74		; fac1 = SQRT(fac2)
-asmsub	EXP		() -> clobbers(A,X,Y) -> ()			= $bfed		; fac1 = EXP(fac1)  (e ** fac1)
-asmsub	NEGOP		() -> clobbers(A) -> ()				= $bfb4		; switch the sign of fac1
-asmsub	RND		() -> clobbers(A,X,Y) -> ()			= $e097		; fac1 = RND(fac1) float random number generator
-asmsub	COS		() -> clobbers(A,X,Y) -> ()			= $e264		; fac1 = COS(fac1)
-asmsub	SIN		() -> clobbers(A,X,Y) -> ()			= $e26b		; fac1 = SIN(fac1)
-asmsub	TAN		() -> clobbers(A,X,Y) -> ()			= $e2b4		; fac1 = TAN(fac1)
-asmsub	ATN		() -> clobbers(A,X,Y) -> ()			= $e30e		; fac1 = ATN(fac1)
+asmsub	NOTOP		() clobbers(A,X,Y)			= $aed4		; fac1 = NOT(fac1)
+asmsub	INT		() clobbers(A,X,Y)			= $bccc		; INT() truncates, use FADDH first to round instead of trunc
+asmsub	LOG		() clobbers(A,X,Y)			= $b9ea		; fac1 = LN(fac1)  (natural log)
+asmsub	SGN		() clobbers(A,X,Y)			= $bc39		; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
+asmsub	SIGN		() -> ubyte @ A				= $bc2b		; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
+asmsub	ABS		()					= $bc58		; fac1 = ABS(fac1)
+asmsub	SQR		() clobbers(A,X,Y)			= $bf71		; fac1 = SQRT(fac1)
+asmsub	SQRA		() clobbers(A,X,Y)			= $bf74		; fac1 = SQRT(fac2)
+asmsub	EXP		() clobbers(A,X,Y)			= $bfed		; fac1 = EXP(fac1)  (e ** fac1)
+asmsub	NEGOP		() clobbers(A)				= $bfb4		; switch the sign of fac1
+asmsub	RND		() clobbers(A,X,Y)			= $e097		; fac1 = RND(fac1) float random number generator
+asmsub	COS		() clobbers(A,X,Y)			= $e264		; fac1 = COS(fac1)
+asmsub	SIN		() clobbers(A,X,Y)			= $e26b		; fac1 = SIN(fac1)
+asmsub	TAN		() clobbers(A,X,Y)			= $e2b4		; fac1 = TAN(fac1)
+asmsub	ATN		() clobbers(A,X,Y)			= $e30e		; fac1 = ATN(fac1)
 
 
 
 
-asmsub  FREADS32  () -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADS32  () clobbers(A,X,Y)  {
 	; ---- fac1 = signed int32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
 		lda  $62
@@ -122,7 +122,7 @@ asmsub  FREADS32  () -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FREADUS32  () -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADUS32  () clobbers(A,X,Y)  {
 	; ---- fac1 = uint32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
 		sec
@@ -132,7 +132,7 @@ asmsub  FREADUS32  () -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) clobbers(A,X,Y)  {
 	; ---- fac1 = signed int24 (A/X/Y contain lo/mid/hi bytes)
 	;      note: there is no FREADU24AXY (unsigned), use FREADUS32 instead.
 	%asm {{
@@ -149,7 +149,7 @@ asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) -> clobbers(A,X
 	}}
 }
 
-asmsub  GIVUAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
+asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
 	%asm {{
 		sty  $62
@@ -160,7 +160,7 @@ asmsub  GIVUAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  GIVAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
+asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
 		sta  c64.SCRATCH_ZPREG
@@ -170,7 +170,7 @@ asmsub  GIVAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FTOSWRDAY  () -> clobbers(X) -> (uword @ AY)  {
+asmsub  FTOSWRDAY  () clobbers(X) -> uword @ AY  {
 	; ---- fac1 to signed word in A/Y
 	%asm {{
 		jsr  FTOSWORDYA	; note the inverse Y/A order
@@ -181,7 +181,7 @@ asmsub  FTOSWRDAY  () -> clobbers(X) -> (uword @ AY)  {
 	}}
 }
 
-asmsub  GETADRAY  () -> clobbers(X) -> (uword @ AY)  {
+asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 	; ---- fac1 to unsigned word in A/Y
 	%asm {{
 		jsr  GETADR		; this uses the inverse order, Y/A
@@ -196,8 +196,8 @@ sub  print_f  (float value) {
 	; ---- prints the floating point value (without a newline) using basic rom routines.
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
-		lda  #<print_f_value
-		ldy  #>print_f_value
+		lda  #<value
+		ldy  #>value
 		jsr  MOVFM		; load float into fac1
 		jsr  FOUT		; fac1 to string in A/Y
 		jsr  c64.STROUT			; print string in A/Y
@@ -310,7 +310,7 @@ stack_uw2float	.proc
 		jmp  push_fac1_as_result
 		.pend
 
-stack_float2w	.proc
+stack_float2w	.proc               ; also used for float2b
 		jsr  pop_float_fac1
 		stx  c64.SCRATCH_ZPREGX
 		jsr  AYINT
@@ -323,7 +323,7 @@ stack_float2w	.proc
 		rts
 		.pend
 
-stack_float2uw	.proc
+stack_float2uw	.proc               ; also used for float2ub
 		jsr  pop_float_fac1
 		stx  c64.SCRATCH_ZPREGX
 		jsr  GETADR

compiler/res/prog8lib/c64lib.p8

@@ -6,7 +6,7 @@
 ; indent format: TABS, size=8
 
 
-~ c64 {
+c64 {
 		const   uword  ESTACK_LO	= $ce00		; evaluation stack (lsb)
 		const   uword  ESTACK_HI	= $cf00		; evaluation stack (msb)
 		&ubyte  SCRATCH_ZPB1		= $02		; scratch byte 1 in ZP
@@ -21,7 +21,7 @@
 		&ubyte  TIME_LO			= $a2		;    .. lo byte. Updated by IRQ every 1/60 sec
 		&ubyte  STKEY			= $91		; various keyboard statuses (updated by IRQ)
 		&ubyte  SFDX			= $cb		; current key pressed (matrix value) (updated by IRQ)
-	
+
 		&ubyte  COLOR			= $0286		; cursor color
 		&ubyte  HIBASE			= $0288		; screen base address / 256 (hi-byte of screen memory address)
 		&uword  CINV			= $0314		; IRQ vector
@@ -63,8 +63,8 @@
 		&ubyte  SP6Y		= $d00d
 		&ubyte  SP7X		= $d00e
 		&ubyte  SP7Y		= $d00f
-		&ubyte[16]  SPXY		= $d000		; the 8 sprite X and Y registers as an array.
-		&uword[8]  SPXYW		= $d000		; the 8 sprite X and Y registers as a combined xy word array.
+		&ubyte[16]  SPXY	= $d000		; the 8 sprite X and Y registers as an array.
+		&uword[8]  SPXYW	= $d000		; the 8 sprite X and Y registers as a combined xy word array.
 
 		&ubyte  MSIGX		= $d010
 		&ubyte  SCROLY		= $d011
@@ -76,7 +76,7 @@
 		&ubyte  YXPAND		= $d017
 		&ubyte  VMCSB		= $d018
 		&ubyte  VICIRQ		= $d019
-		&ubyte  IREQMASK		= $d01a
+		&ubyte  IREQMASK	= $d01a
 		&ubyte  SPBGPR		= $d01b
 		&ubyte  SPMC		= $d01c
 		&ubyte  XXPAND		= $d01d
@@ -98,7 +98,7 @@
 		&ubyte  SP5COL		= $d02c
 		&ubyte  SP6COL		= $d02d
 		&ubyte  SP7COL		= $d02e
-		&ubyte[8]  SPCOL		= $d027
+		&ubyte[8]  SPCOL	= $d027
 
 
 ; ---- end of VIC-II registers ----
@@ -107,8 +107,8 @@
 
 		&ubyte  CIA1PRA		= $DC00		; CIA 1 DRA, keyboard column drive (and joystick control port #2)
 		&ubyte  CIA1PRB		= $DC01		; CIA 1 DRB, keyboard row port (and joystick control port #1)
-		&ubyte  CIA1DDRA		= $DC02		; CIA 1 DDRA, keyboard column
-		&ubyte  CIA1DDRB		= $DC03		; CIA 1 DDRB, keyboard row
+		&ubyte  CIA1DDRA	= $DC02		; CIA 1 DDRA, keyboard column
+		&ubyte  CIA1DDRB	= $DC03		; CIA 1 DDRB, keyboard row
 		&ubyte  CIA1TAL		= $DC04		; CIA 1 timer A low byte
 		&ubyte  CIA1TAH		= $DC05		; CIA 1 timer A high byte
 		&ubyte  CIA1TBL		= $DC06		; CIA 1 timer B low byte
@@ -124,8 +124,8 @@
 
 		&ubyte  CIA2PRA		= $DD00		; CIA 2 DRA, serial port and video address
 		&ubyte  CIA2PRB		= $DD01		; CIA 2 DRB, RS232 port / USERPORT
-		&ubyte  CIA2DDRA		= $DD02		; CIA 2 DDRA, serial port and video address
-		&ubyte  CIA2DDRB		= $DD03		; CIA 2 DDRB, RS232 port / USERPORT
+		&ubyte  CIA2DDRA	= $DD02		; CIA 2 DDRA, serial port and video address
+		&ubyte  CIA2DDRB	= $DD03		; CIA 2 DDRB, RS232 port / USERPORT
 		&ubyte  CIA2TAL		= $DD04		; CIA 2 timer A low byte
 		&ubyte  CIA2TAH		= $DD05		; CIA 2 timer A high byte
 		&ubyte  CIA2TBL		= $DD06		; CIA 2 timer B low byte
@@ -186,8 +186,8 @@
 
 ; ---- C64 basic routines ----
 
-asmsub	CLEARSCR	() -> clobbers(A,X,Y) -> ()		= $E544		; clear the screen
-asmsub	HOMECRSR	() -> clobbers(A,X,Y) -> ()		= $E566		; cursor to top left of screen
+asmsub	CLEARSCR	() clobbers(A,X,Y)		= $E544		; clear the screen
+asmsub	HOMECRSR	() clobbers(A,X,Y)		= $E566		; cursor to top left of screen
 
 
 ; ---- end of C64 basic routines ----
@@ -195,48 +195,48 @@ asmsub	HOMECRSR	() -> clobbers(A,X,Y) -> ()		= $E566		; cursor to top left of sc
 
 ; ---- C64 kernal routines ----
 
-asmsub	STROUT   (uword strptr @ AY) -> clobbers(A, X, Y) -> ()	= $AB1E		; print null-terminated string (use c64scr.print instead)
-asmsub	IRQDFRT  () -> clobbers(A,X,Y) -> ()			= $EA31		; default IRQ routine
-asmsub	IRQDFEND () -> clobbers(A,X,Y) -> ()			= $EA81		; default IRQ end/cleanup
-asmsub	CINT     () -> clobbers(A,X,Y) -> ()			= $FF81		; (alias: SCINIT) initialize screen editor and video chip
-asmsub	IOINIT   () -> clobbers(A, X) -> ()			= $FF84		; initialize I/O devices (CIA, SID, IRQ)
-asmsub	RAMTAS   () -> clobbers(A,X,Y) -> ()			= $FF87		; initialize RAM, tape buffer, screen
-asmsub	RESTOR   () -> clobbers(A,X,Y) -> ()			= $FF8A		; restore default I/O vectors
-asmsub	VECTOR   (ubyte dir @ Pc, uword userptr @ XY) -> clobbers(A,Y) -> ()	= $FF8D		; read/set I/O vector table
-asmsub	SETMSG   (ubyte value @ A) -> clobbers() -> ()		= $FF90		; set Kernal message control flag
-asmsub	SECOND   (ubyte address @ A) -> clobbers(A) -> ()	= $FF93		; (alias: LSTNSA) send secondary address after LISTEN
-asmsub	TKSA     (ubyte address @ A) -> clobbers(A) -> ()	= $FF96		; (alias: TALKSA) send secondary address after TALK
-asmsub	MEMTOP   (ubyte dir @ Pc, uword address @ XY) -> clobbers() -> (uword @ XY)	= $FF99		; read/set top of memory  pointer
-asmsub	MEMBOT   (ubyte dir @ Pc, uword address @ XY) -> clobbers() -> (uword @ XY)	= $FF9C		; read/set bottom of memory  pointer
-asmsub	SCNKEY   () -> clobbers(A,X,Y) -> ()			= $FF9F		; scan the keyboard
-asmsub	SETTMO   (ubyte timeout @ A) -> clobbers() -> ()	= $FFA2		; set time-out flag for IEEE bus
-asmsub	ACPTR    () -> clobbers() -> (ubyte @ A)			= $FFA5		; (alias: IECIN) input byte from serial bus
-asmsub	CIOUT    (ubyte databyte @ A) -> clobbers() -> ()	= $FFA8		; (alias: IECOUT) output byte to serial bus
-asmsub	UNTLK    () -> clobbers(A) -> ()			= $FFAB		; command serial bus device to UNTALK
-asmsub	UNLSN    () -> clobbers(A) -> ()			= $FFAE		; command serial bus device to UNLISTEN
-asmsub	LISTEN   (ubyte device @ A) -> clobbers(A) -> ()	= $FFB1		; command serial bus device to LISTEN
-asmsub	TALK     (ubyte device @ A) -> clobbers(A) -> ()	= $FFB4		; command serial bus device to TALK
-asmsub	READST   () -> clobbers() -> (ubyte @ A)			= $FFB7		; read I/O status word
-asmsub	SETLFS   (ubyte logical @ A, ubyte device @ X, ubyte address @ Y) -> clobbers() -> () = $FFBA	; set logical file parameters
-asmsub	SETNAM   (ubyte namelen @ A, str filename @ XY) -> clobbers() -> ()	= $FFBD		; set filename parameters
-asmsub	OPEN     () -> clobbers(A,X,Y) -> ()			= $FFC0		; (via 794 ($31A)) open a logical file
-asmsub	CLOSE    (ubyte logical @ A) -> clobbers(A,X,Y) -> ()	= $FFC3		; (via 796 ($31C)) close a logical file
-asmsub	CHKIN    (ubyte logical @ X) -> clobbers(A,X) -> ()	= $FFC6		; (via 798 ($31E)) define an input channel
-asmsub	CHKOUT   (ubyte logical @ X) -> clobbers(A,X) -> ()	= $FFC9		; (via 800 ($320)) define an output channel
-asmsub	CLRCHN   () -> clobbers(A,X) -> ()			= $FFCC		; (via 802 ($322)) restore default devices
-asmsub	CHRIN    () -> clobbers(Y) -> (ubyte @ A)		= $FFCF		; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-asmsub	CHROUT   (ubyte char @ A) -> clobbers() -> ()		= $FFD2		; (via 806 ($326)) output a character
-asmsub	LOAD     (ubyte verify @ A, uword address @ XY) -> clobbers() -> (ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y) = $FFD5	; (via 816 ($330)) load from device
-asmsub	SAVE     (ubyte zp_startaddr @ A, uword endaddr @ XY) -> clobbers() -> (ubyte @ Pc, ubyte @ A) = $FFD8	; (via 818 ($332)) save to a device
-asmsub	SETTIM   (ubyte low @ A, ubyte middle @ X, ubyte high @ Y) -> clobbers() -> ()	= $FFDB		; set the software clock
-asmsub	RDTIM    () -> clobbers() -> (ubyte @ A, ubyte @ X, ubyte @ Y) = $FFDE	; read the software clock
-asmsub	STOP     () -> clobbers(A,X) -> (ubyte @ Pz, ubyte @ Pc)	= $FFE1		; (via 808 ($328)) check the STOP key
-asmsub	GETIN    () -> clobbers(X,Y) -> (ubyte @ A)		= $FFE4		; (via 810 ($32A)) get a character
-asmsub	CLALL    () -> clobbers(A,X) -> ()			= $FFE7		; (via 812 ($32C)) close all files
-asmsub	UDTIM    () -> clobbers(A,X) -> ()			= $FFEA		; update the software clock
-asmsub	SCREEN   () -> clobbers() -> (ubyte @ X, ubyte @ Y)	= $FFED		; read number of screen rows and columns
-asmsub	PLOT     (ubyte dir @ Pc, ubyte col @ Y, ubyte row @ X) -> clobbers() -> (ubyte @ X, ubyte @ Y)	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
-asmsub	IOBASE   () -> clobbers() -> (uword @ XY)		= $FFF3		; read base address of I/O devices
+asmsub	STROUT   (uword strptr @ AY) clobbers(A, X, Y)	= $AB1E		; print null-terminated string (use c64scr.print instead)
+asmsub	IRQDFRT  () clobbers(A,X,Y)			= $EA31		; default IRQ routine
+asmsub	IRQDFEND () clobbers(A,X,Y)			= $EA81		; default IRQ end/cleanup
+asmsub	CINT     () clobbers(A,X,Y)			= $FF81		; (alias: SCINIT) initialize screen editor and video chip
+asmsub	IOINIT   () clobbers(A, X)			= $FF84		; initialize I/O devices (CIA, SID, IRQ)
+asmsub	RAMTAS   () clobbers(A,X,Y)			= $FF87		; initialize RAM, tape buffer, screen
+asmsub	RESTOR   () clobbers(A,X,Y)			= $FF8A		; restore default I/O vectors
+asmsub	VECTOR   (uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)  = $FF8D		; read/set I/O vector table
+asmsub	SETMSG   (ubyte value @ A)			= $FF90		; set Kernal message control flag
+asmsub	SECOND   (ubyte address @ A) clobbers(A)	= $FF93		; (alias: LSTNSA) send secondary address after LISTEN
+asmsub	TKSA     (ubyte address @ A) clobbers(A)	= $FF96		; (alias: TALKSA) send secondary address after TALK
+asmsub	MEMTOP   (uword address @ XY, ubyte dir @ Pc) -> uword @ XY	= $FF99		; read/set top of memory  pointer
+asmsub	MEMBOT   (uword address @ XY, ubyte dir @ Pc) -> uword @ XY	= $FF9C		; read/set bottom of memory  pointer
+asmsub	SCNKEY   () clobbers(A,X,Y)			= $FF9F		; scan the keyboard
+asmsub	SETTMO   (ubyte timeout @ A)			= $FFA2		; set time-out flag for IEEE bus
+asmsub	ACPTR    () -> ubyte @ A			= $FFA5		; (alias: IECIN) input byte from serial bus
+asmsub	CIOUT    (ubyte databyte @ A)			= $FFA8		; (alias: IECOUT) output byte to serial bus
+asmsub	UNTLK    () clobbers(A)				= $FFAB		; command serial bus device to UNTALK
+asmsub	UNLSN    () clobbers(A)				= $FFAE		; command serial bus device to UNLISTEN
+asmsub	LISTEN   (ubyte device @ A) clobbers(A)		= $FFB1		; command serial bus device to LISTEN
+asmsub	TALK     (ubyte device @ A) clobbers(A)		= $FFB4		; command serial bus device to TALK
+asmsub	READST   () -> ubyte @ A			= $FFB7		; read I/O status word
+asmsub	SETLFS   (ubyte logical @ A, ubyte device @ X, ubyte address @ Y) = $FFBA	; set logical file parameters
+asmsub	SETNAM   (ubyte namelen @ A, str filename @ XY)	= $FFBD		; set filename parameters
+asmsub	OPEN     () clobbers(A,X,Y)			= $FFC0		; (via 794 ($31A)) open a logical file
+asmsub	CLOSE    (ubyte logical @ A) clobbers(A,X,Y)	= $FFC3		; (via 796 ($31C)) close a logical file
+asmsub	CHKIN    (ubyte logical @ X) clobbers(A,X)	= $FFC6		; (via 798 ($31E)) define an input channel
+asmsub	CHKOUT   (ubyte logical @ X) clobbers(A,X)	= $FFC9		; (via 800 ($320)) define an output channel
+asmsub	CLRCHN   () clobbers(A,X)			= $FFCC		; (via 802 ($322)) restore default devices
+asmsub	CHRIN    () clobbers(Y) -> ubyte @ A		= $FFCF		; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
+asmsub	CHROUT   (ubyte char @ A)			= $FFD2		; (via 806 ($326)) output a character
+asmsub	LOAD     (ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y = $FFD5	; (via 816 ($330)) load from device
+asmsub	SAVE     (ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A = $FFD8	; (via 818 ($332)) save to a device
+asmsub	SETTIM   (ubyte low @ A, ubyte middle @ X, ubyte high @ Y)	= $FFDB		; set the software clock
+asmsub	RDTIM    () -> ubyte @ A, ubyte @ X, ubyte @ Y	= $FFDE	; read the software clock
+asmsub	STOP     () clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc	= $FFE1		; (via 808 ($328)) check the STOP key
+asmsub	GETIN    () clobbers(X,Y) -> ubyte @ A		= $FFE4		; (via 810 ($32A)) get a character
+asmsub	CLALL    () clobbers(A,X)			= $FFE7		; (via 812 ($32C)) close all files
+asmsub	UDTIM    () clobbers(A,X)			= $FFEA		; update the software clock
+asmsub	SCREEN   () -> ubyte @ X, ubyte @ Y		= $FFED		; read number of screen rows and columns
+asmsub	PLOT     (ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
+asmsub	IOBASE   () -> uword @ XY			= $FFF3		; read base address of I/O devices
 
 ; ---- end of C64 kernal routines ----
 

compiler/res/prog8lib/c64utils.p8

@@ -9,7 +9,7 @@
 %import c64lib
 
 
-~ c64utils {
+c64utils {
 
 		const   uword  ESTACK_LO	= $ce00
 		const   uword  ESTACK_HI	= $cf00
@@ -17,7 +17,7 @@
 
 ; ----- utility functions ----
 
-asmsub  ubyte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X, ubyte @ A)  {
+asmsub  ubyte2decimal  (ubyte value @ A) -> ubyte @ Y, ubyte @ X, ubyte @ A  {
 	; ---- A to decimal string in Y/X/A  (100s in Y, 10s in X, 1s in A)
 	%asm {{
 		ldy  #$2f
@@ -34,7 +34,7 @@ asmsub  ubyte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X,
 	}}
 }
 
-asmsub  byte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X, ubyte @ A)  {
+asmsub  byte2decimal  (ubyte value @ A) -> ubyte @ Y, ubyte @ X, ubyte @ A  {
 	; ---- A (signed byte) to decimal string in Y/X/A  (100s in Y, 10s in X, 1s in A)
 	;      note: the '-' is not part of the conversion here if it's a negative number
 	%asm {{
@@ -47,7 +47,7 @@ asmsub  byte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X,
 	}}
 }
 
-asmsub  ubyte2hex  (ubyte value @ A) -> clobbers() -> (ubyte @ A, ubyte @ Y)  {
+asmsub  ubyte2hex  (ubyte value @ A) -> ubyte @ A, ubyte @ Y  {
 	; ---- A to hex string in AY (first hex char in A, second hex char in Y)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -70,7 +70,7 @@ _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as
 }
 
 
-asmsub  uword2hex  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  uword2hex  (uword value @ AY) clobbers(A,Y)  {
 	; ---- convert 16 bit uword in A/Y into 4-character hexadecimal string 'uword2hex.output' (0-terminated)
 	%asm {{
 		sta  c64.SCRATCH_ZPREG
@@ -87,7 +87,7 @@ output	.text  "0000", $00      ; 0-terminated output buffer (to make printing ea
 	}}
 }
 
-asmsub  uword2bcd  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  uword2bcd  (uword value @ AY) clobbers(A,Y)  {
 	; Convert an 16 bit binary value to BCD
 	;
 	; This function converts a 16 bit binary value in A/Y into a 24 bit BCD. It
@@ -134,7 +134,7 @@ bcdbuff  .byte  0,0,0
 }
 
 
-asmsub  uword2decimal  (uword value @ AY) -> clobbers(A) -> (ubyte @ Y)  {
+asmsub  uword2decimal  (uword value @ AY) clobbers(A) -> ubyte @ Y  {
 	; ---- convert 16 bit uword in A/Y into 0-terminated decimal string into memory  'uword2decimal.output'
 	;      returns length of resulting string in Y
 	%asm {{
@@ -173,7 +173,7 @@ output  .text  "00000", $00     ; 0 terminated
 }
 
 
-asmsub str2uword(str string @ AY) -> clobbers() -> (uword @ AY) {
+asmsub str2uword(str string @ AY) -> uword @ AY {
 	; -- returns the unsigned word value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
@@ -228,7 +228,7 @@ _result_times_10     ; (W*4 + W)*2
 }
 
 
-asmsub str2word(str string @ AY) -> clobbers() -> (word @ AY) {
+asmsub str2word(str string @ AY) -> word @ AY {
 	; -- returns the signed word value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
@@ -284,7 +284,7 @@ _negative	.byte  0
 }
 
 
-asmsub  set_irqvec_excl() -> clobbers(A) -> ()  {
+asmsub  set_irqvec_excl() clobbers(A)  {
 	%asm {{
 		sei
 		lda  #<_irq_handler
@@ -303,7 +303,7 @@ _irq_handler	jsr  set_irqvec._irq_handler_init
 	}}
 }
 
-asmsub  set_irqvec() -> clobbers(A) -> ()  {
+asmsub  set_irqvec() clobbers(A)  {
 	%asm {{
 		sei
 		lda  #<_irq_handler
@@ -373,7 +373,7 @@ IRQ_SCRATCH_ZPWORD2	.word  0
 }
 
 
-asmsub  restore_irqvec() -> clobbers() -> () {
+asmsub  restore_irqvec() {
 	%asm {{
 		sei
 		lda  #<c64.IRQDFRT
@@ -390,7 +390,7 @@ asmsub  restore_irqvec() -> clobbers() -> () {
 }
 
 
-asmsub  set_rasterirq(uword rasterpos @ AY) -> clobbers(A) -> () {
+asmsub  set_rasterirq(uword rasterpos @ AY) clobbers(A) {
 	%asm {{
 		sei
 		jsr  _setup_raster_irq
@@ -431,7 +431,7 @@ _setup_raster_irq
 	}}
 }
 
-asmsub  set_rasterirq_excl(uword rasterpos @ AY) -> clobbers(A) -> () {
+asmsub  set_rasterirq_excl(uword rasterpos @ AY) clobbers(A) {
 	%asm {{
 		sei
 		jsr  set_rasterirq._setup_raster_irq
@@ -461,11 +461,11 @@ _raster_irq_handler
 
 
 
-~ c64scr {
+c64scr {
 	; ---- this block contains (character) Screen and text I/O related functions ----
 
 
-asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) -> clobbers(A) -> ()  {
+asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- clear the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
 
@@ -481,7 +481,7 @@ asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) -> clobbers(A) -> ()  {
 }
 
 
-asmsub  clear_screenchars (ubyte char @ A) -> clobbers(Y) -> ()  {
+asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	%asm {{
@@ -501,7 +501,7 @@ _loop		sta  c64.Screen,y
         }}
 }
 
-asmsub  clear_screencolors (ubyte color @ A) -> clobbers(Y) -> ()  {
+asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
 	; ---- clear the character screen colors with the given color (leaves characters).
 	;      (assumes color matrix is at the default address)
 	%asm {{
@@ -522,7 +522,7 @@ _loop		sta  c64.Colors,y
 }
 
 
-asmsub  scroll_left_full  (ubyte alsocolors @ Pc) -> clobbers(A, Y) -> ()  {
+asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -583,7 +583,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_right_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_right_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -636,7 +636,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_up_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -689,7 +689,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_down_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -743,7 +743,7 @@ _scroll_screen  ; scroll the screen memory
 
 
 
-asmsub  print (str text @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print (str text @ AY) clobbers(A,Y)  {
 	; ---- print null terminated string from A/Y
 	; note: the compiler contains an optimization that will replace
 	;       a call to this subroutine with a string argument of just one char,
@@ -762,7 +762,7 @@ asmsub  print (str text @ AY) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ub0  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -780,7 +780,7 @@ asmsub  print_ub0  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ub  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -803,7 +803,7 @@ _end		pla
 	}}
 }
 
-asmsub  print_b  (byte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -821,7 +821,7 @@ asmsub  print_b  (byte value @ A) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ubhex  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -840,7 +840,7 @@ asmsub  print_ubhex  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) -> ()
 }
 
 
-asmsub  print_ubbin  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) ->()  {
+asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -862,7 +862,7 @@ asmsub  print_ubbin  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) ->()
 }
 
 
-asmsub  print_uwbin  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) ->()  {
+asmsub  print_uwbin  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -875,7 +875,7 @@ asmsub  print_uwbin  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) ->()
 }
 
 
-asmsub print_uwhex  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -889,7 +889,7 @@ asmsub print_uwhex  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) -> ()
 }
 
 
-asmsub  print_uw0  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
 		jsr  c64utils.uword2decimal
@@ -904,7 +904,7 @@ asmsub  print_uw0  (uword value @ AY) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_uw  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
 		jsr  c64utils.uword2decimal
@@ -936,7 +936,7 @@ _pr_decimal
 	}}
 }
 
-asmsub  print_w  (word value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -957,7 +957,7 @@ asmsub  print_w  (word value @ AY) -> clobbers(A,Y) -> ()  {
 	}}
 }
 
-asmsub  input_chars  (uword buffer @ AY) -> clobbers(A) -> (ubyte @ Y)  {
+asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
 	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
 	;      It assumes the keyboard is selected as I/O channel!
 
@@ -978,7 +978,7 @@ asmsub  input_chars  (uword buffer @ AY) -> clobbers(A) -> (ubyte @ Y)  {
 	}}
 }
 
-asmsub  setchr  (ubyte col @Y, ubyte row @A) -> clobbers(A) -> ()  {
+asmsub  setchr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
 	; ---- set the character in SCRATCH_ZPB1 on the screen matrix at the given position
 	%asm {{
 		sty  c64.SCRATCH_ZPREG
@@ -1000,7 +1000,7 @@ _screenrows	.word  $0400 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getchr  (ubyte col @Y, ubyte row @A) -> clobbers(Y) -> (ubyte @ A) {
+asmsub  getchr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
 	; ---- get the character in the screen matrix at the given location
 	%asm  {{
 		sty  c64.SCRATCH_ZPB1
@@ -1019,7 +1019,7 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-asmsub  setclr  (ubyte col @Y, ubyte row @A) -> clobbers(A) -> ()  {
+asmsub  setclr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
 	; ---- set the color in SCRATCH_ZPB1 on the screen matrix at the given position
 	%asm {{
 		sty  c64.SCRATCH_ZPREG
@@ -1041,7 +1041,7 @@ _colorrows	.word  $d800 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getclr  (ubyte col @Y, ubyte row @A) -> clobbers(Y) -> (ubyte @ A) {
+asmsub  getclr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
 	; ---- get the color in the screen color matrix at the given location
 	%asm  {{
 		sty  c64.SCRATCH_ZPB1
@@ -1063,7 +1063,7 @@ _mod		lda  $ffff		; modified
 sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte color)  {
 	; ---- set char+color at the given position on the screen
 	%asm {{
-		lda  setcc_row
+		lda  row
 		asl  a
 		tay
 		lda  setchr._screenrows+1,y
@@ -1072,21 +1072,21 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte color)  {
 		sta  _colormod+2
 		lda  setchr._screenrows,y
 		clc
-		adc  setcc_column
+		adc  column
 		sta  _charmod+1
 		sta  _colormod+1
 		bcc  +
 		inc  _charmod+2
 		inc  _colormod+2
-+		lda  setcc_char
++		lda  char
 _charmod	sta  $ffff		; modified
-		lda  setcc_color
+		lda  color
 _colormod	sta  $ffff		; modified
 		rts
 	}}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) -> clobbers(A) -> () {
+asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
 	; ---- safe wrapper around PLOT kernel routine, to save the X register.
 	%asm  {{
 		stx  c64.SCRATCH_ZPREGX

compiler/res/prog8lib/math.p8

@@ -6,6 +6,6 @@
 
 %import c64lib
 
-~ math {
+math {
 	%asminclude "library:math.asm", ""
 }

compiler/res/prog8lib/prog8lib.asm

@@ -35,6 +35,17 @@ init_system	.proc
 		rts
 		.pend
 
+		
+read_byte_from_address	.proc
+	; -- read the byte from the memory address on the top of the stack, return in A (stack remains unchanged)
+		lda  c64.ESTACK_LO+1,x
+		ldy  c64.ESTACK_HI+1,x
+		sta  (+) +1
+		sty  (+) +2
++		lda  $ffff		; modified
+		rts
+		.pend
+		
 
 add_a_to_zpword	.proc
 	; -- add ubyte in A to the uword in c64.SCRATCH_ZPWORD1

compiler/res/prog8lib/prog8lib.p8

@@ -6,6 +6,6 @@
 
 %import c64lib
 
-~ prog8_lib {
+prog8_lib {
 	%asminclude "library:prog8lib.asm", ""
 }

compiler/res/version.txt

@@ -1 +1 @@
-1.7
+1.50

compiler/src/prog8/CompilerMain.kt

@@ -1,31 +1,20 @@
 package prog8
 
-import prog8.ast.*
-import prog8.compiler.*
-import prog8.compiler.target.c64.AsmGen
-import prog8.compiler.target.c64.C64Zeropage
-import prog8.optimizing.constantFold
-import prog8.optimizing.optimizeStatements
-import prog8.optimizing.simplifyExpressions
+import prog8.ast.base.AstException
+import prog8.compiler.CompilationResult
+import prog8.compiler.compileProgram
 import prog8.parser.ParsingFailedError
-import prog8.parser.importModule
-import java.io.File
-import java.io.PrintStream
-import java.lang.Exception
+import prog8.vm.astvm.AstVm
+import java.nio.file.FileSystems
+import java.nio.file.Path
 import java.nio.file.Paths
+import java.nio.file.StandardWatchEventKinds
+import java.util.*
 import kotlin.system.exitProcess
-import kotlin.system.measureTimeMillis
 
 
 fun main(args: Array<String>) {
 
-    // check if the user wants to launch the VM instead
-    if("-vm" in args) {
-        val newArgs = args.toMutableList()
-        newArgs.remove("-vm")
-        return stackVmMain(newArgs.toTypedArray())
-    }
-
     printSoftwareHeader("compiler")
 
     if (args.isEmpty())
@@ -33,10 +22,9 @@ fun main(args: Array<String>) {
     compileMain(args)
 }
 
-fun printSoftwareHeader(what: String) {
+internal fun printSoftwareHeader(what: String) {
     val buildVersion = object {}.javaClass.getResource("/version.txt").readText().trim()
-    println("\nProg8 $what by Irmen de Jong (irmen@razorvine.net)")
-    println("Version: $buildVersion")
+    println("\nProg8 $what v$buildVersion by Irmen de Jong (irmen@razorvine.net)")
     println("This software is licensed under the GNU GPL 3.0, see https://www.gnu.org/licenses/gpl.html\n")
 }
 
@@ -44,185 +32,110 @@ fun printSoftwareHeader(what: String) {
 private fun compileMain(args: Array<String>) {
     var emulatorToStart = ""
     var moduleFile = ""
-    var writeVmCode = false
     var writeAssembly = true
     var optimize = true
+    var optimizeInlining = true
+    var launchAstVm = false
+    var watchMode = false
     for (arg in args) {
         if(arg=="-emu")
             emulatorToStart = "x64"
         else if(arg=="-emu2")
             emulatorToStart = "x64sc"
-        else if(arg=="-writevm")
-            writeVmCode = true
         else if(arg=="-noasm")
             writeAssembly = false
         else if(arg=="-noopt")
             optimize = false
+        else if(arg=="-nooptinline")
+            optimizeInlining = false
+        else if(arg=="-avm")
+            launchAstVm = true
+        else if(arg=="-watch")
+            watchMode = true
         else if(!arg.startsWith("-"))
             moduleFile = arg
         else
             usage()
     }
-    if(moduleFile.isBlank())
-        usage()
 
-    val filepath = Paths.get(moduleFile).normalize()
-    var programname = "?"
+    if(watchMode) {
+        if(moduleFile.isBlank())
+            usage()
 
-    try {
-        val totalTime = measureTimeMillis {
-            // import main module and process additional imports
-            println("Parsing...")
-            val moduleAst = importModule(filepath)
-            moduleAst.linkParents()
-            var namespace = moduleAst.definingScope()
+        val watchservice = FileSystems.getDefault().newWatchService()
 
-            // determine special compiler options
+        while(true) {
+            val filepath = Paths.get(moduleFile).normalize()
+            println("Continuous watch mode active. Main module: $filepath")
 
-            val compilerOptions = determineCompilationOptions(moduleAst)
-
-            if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
-                throw ParsingFailedError("${moduleAst.position} BASIC launcher requires output type PRG.")
-
-            // perform initial syntax checks and constant folding
-            println("Syntax check...")
-            val heap = HeapValues()
-            val time1= measureTimeMillis {
-                moduleAst.checkIdentifiers(namespace)
-            }
-            //println(" time1: $time1")
-            val time2 = measureTimeMillis {
-                moduleAst.constantFold(namespace, heap)
-            }
-            //println(" time2: $time2")
-            val time3 = measureTimeMillis {
-                moduleAst.reorderStatements(namespace,heap)     // reorder statements to please the compiler later
-            }
-            //println(" time3: $time3")
-            val time4 = measureTimeMillis {
-                moduleAst.checkValid(namespace, compilerOptions, heap)          // check if tree is valid
-            }
-            //println(" time4: $time4")
-
-            moduleAst.checkIdentifiers(namespace)
-            if(optimize) {
-                // optimize the parse tree
-                println("Optimizing...")
-                while (true) {
-                    // keep optimizing expressions and statements until no more steps remain
-                    val optsDone1 = moduleAst.simplifyExpressions(namespace, heap)
-                    val optsDone2 = moduleAst.optimizeStatements(namespace, heap)
-                    if (optsDone1 + optsDone2 == 0)
-                        break
+            try {
+                val compilationResult = compileProgram(filepath, optimize, optimizeInlining, writeAssembly)
+                println("Imported files (now watching:)")
+                for (importedFile in compilationResult.importedFiles) {
+                    print("  ")
+                    println(importedFile)
+                    importedFile.parent.register(watchservice, StandardWatchEventKinds.ENTRY_MODIFY)
                 }
-            }
-
-            namespace = moduleAst.definingScope()       // create it again, it could have changed in the meantime
-            moduleAst.checkValid(namespace, compilerOptions, heap)          // check if final tree is valid
-            moduleAst.checkRecursion(namespace)         // check if there are recursive subroutine calls
-
-            // namespace.debugPrint()
-
-            // compile the syntax tree into stackvmProg form, and optimize that
-            val compiler = Compiler(moduleAst, namespace, heap)
-            val intermediate = compiler.compile(compilerOptions)
-            if(optimize)
-                intermediate.optimize()
-
-            if(writeVmCode) {
-                val stackVmFilename = intermediate.name + ".vm.txt"
-                val stackvmFile = PrintStream(File(stackVmFilename), "utf-8")
-                intermediate.writeCode(stackvmFile)
-                stackvmFile.close()
-                println("StackVM program code written to '$stackVmFilename'")
-            }
-
-            if(writeAssembly) {
-                val zeropage = C64Zeropage(compilerOptions)
-                intermediate.allocateZeropage(zeropage)
-                val assembly = AsmGen(compilerOptions, intermediate, heap, zeropage).compileToAssembly(optimize)
-                assembly.assemble(compilerOptions)
-                programname = assembly.name
+                println("${Date()}: Waiting for file changes.")
+                val event = watchservice.take()
+                for(changed in event.pollEvents()) {
+                    val changedPath = changed.context() as Path
+                    println("  change detected: ${changedPath}")
+                }
+                event.reset()
+                println("\u001b[H\u001b[2J")      // clear the screen
+            } catch (x: Exception) {
+                throw x
             }
         }
-        println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
 
-    } catch (px: ParsingFailedError) {
-        System.err.print("\u001b[91m")  // bright red
-        System.err.println(px.message)
-        System.err.print("\u001b[0m")  // reset
-        exitProcess(1)
-    } catch (ax: AstException) {
-        System.err.print("\u001b[91m")  // bright red
-        System.err.println(ax.toString())
-        System.err.print("\u001b[0m")  // reset
-        exitProcess(1)
-    } catch (x: Exception) {
-        print("\u001b[91m")  // bright red
-        println("\n* internal error *")
-        print("\u001b[0m")  // reset
-        System.out.flush()
-        throw x
-    } catch (x: NotImplementedError) {
-        print("\u001b[91m")  // bright red
-        println("\n* internal error: missing feature/code *")
-        print("\u001b[0m")  // reset
-        System.out.flush()
-        throw x
-    }
+    } else {
+        if(moduleFile.isBlank())
+            usage()
 
-    if(emulatorToStart.isNotEmpty()) {
-        println("\nStarting C-64 emulator $emulatorToStart...")
-        val cmdline = listOf(emulatorToStart, "-silent", "-moncommands", "$programname.vice-mon-list",
-                "-autostartprgmode", "1", "-autostart-warp", "-autostart", programname+".prg")
-        val process = ProcessBuilder(cmdline).inheritIO().start()
-        process.waitFor()
+        val filepath = Paths.get(moduleFile).normalize()
+        val compilationResult: CompilationResult
+
+        try {
+            compilationResult = compileProgram(filepath, optimize, optimizeInlining, writeAssembly)
+            if(!compilationResult.success)
+                exitProcess(1)
+        } catch (x: ParsingFailedError) {
+            exitProcess(1)
+        } catch (x: AstException) {
+            exitProcess(1)
+        }
+
+        if (launchAstVm) {
+            println("\nLaunching AST-based vm...")
+            val vm = AstVm(compilationResult.programAst)
+            vm.run()
+        }
+
+        if (emulatorToStart.isNotEmpty()) {
+            if (compilationResult.programName.isEmpty())
+                println("\nCan't start emulator because no program was assembled.")
+            else {
+                println("\nStarting C-64 emulator $emulatorToStart...")
+                val cmdline = listOf(emulatorToStart, "-silent", "-moncommands", "${compilationResult.programName}.vice-mon-list",
+                        "-autostartprgmode", "1", "-autostart-warp", "-autostart", compilationResult.programName + ".prg")
+                val process = ProcessBuilder(cmdline).inheritIO().start()
+                process.waitFor()
+            }
+        }
     }
 }
 
-fun determineCompilationOptions(moduleAst: Module): CompilationOptions {
-    val options = moduleAst.statements.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.toSet()
-    val outputType = (moduleAst.statements.singleOrNull { it is Directive && it.directive == "%output" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    val launcherType = (moduleAst.statements.singleOrNull { it is Directive && it.directive == "%launcher" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    moduleAst.loadAddress = (moduleAst.statements.singleOrNull { it is Directive && it.directive == "%address" }
-            as? Directive)?.args?.single()?.int ?: 0
-    val zpoption: String? = (moduleAst.statements.singleOrNull { it is Directive && it.directive == "%zeropage" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    val floatsEnabled = options.any { it.name == "enable_floats" }
-    val zpType: ZeropageType =
-            if (zpoption == null)
-                if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
-            else
-                try {
-                    ZeropageType.valueOf(zpoption)
-                } catch (x: IllegalArgumentException) {
-                    ZeropageType.KERNALSAFE
-                    // error will be printed by the astchecker
-                }
-    val zpReserved = moduleAst.statements
-            .asSequence()
-            .filter { it is Directive && it.directive == "%zpreserved" }
-            .map { (it as Directive).args }
-            .map { it[0].int!!..it[1].int!! }
-            .toList()
-
-    return CompilationOptions(
-            if (outputType == null) OutputType.PRG else OutputType.valueOf(outputType),
-            if (launcherType == null) LauncherType.BASIC else LauncherType.valueOf(launcherType),
-            zpType, zpReserved, floatsEnabled
-    )
-}
 
 private fun usage() {
     System.err.println("Missing argument(s):")
-    System.err.println("    [-emu]       auto-start the 'x64' C-64 emulator after successful compilation")
-    System.err.println("    [-emu2]      auto-start the 'x64sc' C-64 emulator after successful compilation")
-    System.err.println("    [-writevm]   write intermediate vm code to a file as well")
-    System.err.println("    [-noasm]     don't create assembly code")
-    System.err.println("    [-vm]        launch the prog8 virtual machine instead of the compiler")
-    System.err.println("    [-noopt]     don't perform optimizations")
-    System.err.println("    modulefile   main module file to compile")
+    System.err.println("    [-noasm]        don't create assembly code")
+    System.err.println("    [-noopt]        don't perform any optimizations")
+    System.err.println("    [-nooptinline]  don't perform subroutine inlining optimizations")
+    System.err.println("    [-emu]          auto-start the 'x64' C-64 emulator after successful compilation")
+    System.err.println("    [-emu2]         auto-start the 'x64sc' C-64 emulator after successful compilation")
+    System.err.println("    [-avm]          launch the prog8 ast-based virtual machine after compilation")
+    System.err.println("    [-watch]        continuous compilation mode (watches for file changes)")
+    System.err.println("    modulefile      main module file to compile")
     exitProcess(1)
 }

compiler/src/prog8/ast/AstIdentifiersChecker.kt

@@ -1,242 +0,0 @@
-package prog8.ast
-
-import prog8.functions.BuiltinFunctions
-
-/**
- * Checks the validity of all identifiers (no conflicts)
- * Also makes sure that subroutine's parameters also become local variable decls in the subroutine's scope.
- * Finally, it also makes sure the datatype of all Var decls and sub Return values is set correctly.
- */
-
-fun Module.checkIdentifiers(namespace: INameScope) {
-    val checker = AstIdentifiersChecker(namespace)
-    this.process(checker)
-
-    // add any anonymous variables for heap values that are used,
-    // and replace an iterable literalvalue by identifierref to new local variable
-    for (variable in checker.anonymousVariablesFromHeap.values) {
-        val scope = variable.first.definingScope()
-        scope.statements.add(variable.second)
-        val parent = variable.first.parent
-        when {
-            parent is Assignment && parent.value === variable.first -> {
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.value = idref
-            }
-            parent is IFunctionCall -> {
-                val parameterPos = parent.arglist.indexOf(variable.first)
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.arglist[parameterPos] = idref
-            }
-            parent is ForLoop -> {
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.iterable = idref
-            }
-            else -> TODO("replace literalvalue by identifierref: $variable  (in $parent)")
-        }
-        variable.second.linkParents(scope as Node)
-    }
-
-    printErrors(checker.result(), name)
-}
-
-
-private class AstIdentifiersChecker(private val namespace: INameScope) : IAstProcessor {
-    private val checkResult: MutableList<AstException> = mutableListOf()
-
-    var blocks: MutableMap<String, Block> = mutableMapOf()
-        private set
-
-    fun result(): List<AstException> {
-        return checkResult
-    }
-
-    private fun nameError(name: String, position: Position, existing: IStatement) {
-        checkResult.add(NameError("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position))
-    }
-
-    override fun process(block: Block): IStatement {
-        val existing = blocks[block.name]
-        if(existing!=null)
-            nameError(block.name, block.position, existing)
-        else
-            blocks[block.name] = block
-
-        return super.process(block)
-    }
-
-    override fun process(functionCall: FunctionCall): IExpression {
-        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
-            // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
-            val typecast = TypecastExpression(functionCall.arglist.single(), DataType.UBYTE, functionCall.position)
-            typecast.linkParents(functionCall.parent)
-            return super.process(typecast)
-        }
-        return super.process(functionCall)
-    }
-
-    override fun process(decl: VarDecl): IStatement {
-        // first, check if there are datatype errors on the vardecl
-        decl.datatypeErrors.forEach { checkResult.add(it) }
-
-        // now check the identifier
-        if(decl.name in BuiltinFunctions)
-            // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", decl.position))
-
-        val existing = namespace.lookup(listOf(decl.name), decl)
-        if (existing != null && existing !== decl)
-            nameError(decl.name, decl.position, existing)
-
-        return super.process(decl)
-    }
-
-    override fun process(subroutine: Subroutine): IStatement {
-        if(subroutine.name in BuiltinFunctions) {
-            // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", subroutine.position))
-        } else {
-            if (subroutine.parameters.any { it.name in BuiltinFunctions })
-                checkResult.add(NameError("builtin function name cannot be used as parameter", subroutine.position))
-
-            val existing = namespace.lookup(listOf(subroutine.name), subroutine)
-            if (existing != null && existing !== subroutine)
-                nameError(subroutine.name, subroutine.position, existing)
-
-            // check that there are no local variables that redefine the subroutine's parameters
-            val allDefinedNames = subroutine.allLabelsAndVariables()
-            val paramNames = subroutine.parameters.map { it.name }.toSet()
-            val paramsToCheck = paramNames.intersect(allDefinedNames)
-            for(name in paramsToCheck) {
-                val thing = subroutine.getLabelOrVariable(name)!!
-                if(thing.position != subroutine.position)
-                    nameError(name, thing.position, subroutine)
-            }
-
-            // inject subroutine params as local variables (if they're not there yet) (for non-kernel subroutines and non-asm parameters)
-            // NOTE:
-            // - numeric types BYTE and WORD and FLOAT are passed by value;
-            // - strings, arrays, matrices are passed by reference (their 16-bit address is passed as an uword parameter)
-            // - do NOT do this is the statement can be transformed into an asm subroutine later!
-            if(subroutine.asmAddress==null && !subroutine.canBeAsmSubroutine) {
-                if(subroutine.asmParameterRegisters.isEmpty()) {
-                    subroutine.parameters
-                            .filter { it.name !in allDefinedNames }
-                            .forEach {
-                                val vardecl = VarDecl(VarDeclType.VAR, it.type, false, null, false, it.name, null, subroutine.position)
-                                vardecl.linkParents(subroutine)
-                                subroutine.statements.add(0, vardecl)
-                            }
-                }
-            }
-        }
-        return super.process(subroutine)
-    }
-
-    override fun process(label: Label): IStatement {
-        if(label.name in BuiltinFunctions) {
-            // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", label.position))
-        } else {
-            val existing = namespace.lookup(listOf(label.name), label)
-            if (existing != null && existing !== label)
-                nameError(label.name, label.position, existing)
-        }
-        return super.process(label)
-    }
-
-    override fun process(forLoop: ForLoop): IStatement {
-        // If the for loop has a decltype, it means to declare the loopvar inside the loop body
-        // rather than reusing an already declared loopvar from an outer scope.
-        // For loops that loop over an interable variable (instead of a range of numbers) get an
-        // additional interation count variable in their scope.
-        if(forLoop.loopRegister!=null) {
-            if(forLoop.decltype!=null)
-                checkResult.add(SyntaxError("register loop variables cannot be explicitly declared with a datatype", forLoop.position))
-            if(forLoop.loopRegister == Register.X)
-                printWarning("writing to the X register is dangerous, because it's used as an internal pointer", forLoop.position)
-        } else if(forLoop.loopVar!=null) {
-            val varName = forLoop.loopVar.nameInSource.last()
-            if(forLoop.decltype!=null) {
-                val existing = if(forLoop.body.isEmpty()) null else forLoop.body.lookup(forLoop.loopVar.nameInSource, forLoop.body.statements.first())
-                if(existing==null) {
-                    // create the local scoped for loop variable itself
-                    val vardecl = VarDecl(VarDeclType.VAR, forLoop.decltype, true, null, false, varName, null, forLoop.loopVar.position)
-                    vardecl.linkParents(forLoop.body)
-                    forLoop.body.statements.add(0, vardecl)
-                    forLoop.loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
-                }
-
-            }
-
-            if(forLoop.iterable !is RangeExpr) {
-                val existing = if(forLoop.body.isEmpty()) null else forLoop.body.lookup(listOf(ForLoop.iteratorLoopcounterVarname), forLoop.body.statements.first())
-                if(existing==null) {
-                    // create loop iteration counter variable (without value, to avoid an assignment)
-                    val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, true, null, false, ForLoop.iteratorLoopcounterVarname, null, forLoop.loopVar.position)
-                    vardecl.linkParents(forLoop.body)
-                    forLoop.body.statements.add(0, vardecl)
-                    forLoop.loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
-                }
-            }
-        }
-        return super.process(forLoop)
-    }
-
-    override fun process(assignTarget: AssignTarget): AssignTarget {
-        if(assignTarget.register==Register.X)
-            printWarning("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
-        return super.process(assignTarget)
-    }
-
-    override fun process(returnStmt: Return): IStatement {
-        if(returnStmt.values.isNotEmpty()) {
-            // possibly adjust any literal values returned, into the desired returning data type
-            val subroutine = returnStmt.definingSubroutine()!!
-            if(subroutine.returntypes.size!=returnStmt.values.size)
-                return returnStmt  // mismatch in number of return values, error will be printed later.
-            val newValues = mutableListOf<IExpression>()
-            for(returnvalue in returnStmt.values.zip(subroutine.returntypes)) {
-                val lval = returnvalue.first as? LiteralValue
-                if(lval!=null) {
-                    val adjusted = lval.intoDatatype(returnvalue.second)
-                    if(adjusted!=null && adjusted !== lval)
-                        newValues.add(adjusted)
-                    else
-                        newValues.add(lval)
-                }
-                else
-                    newValues.add(returnvalue.first)
-            }
-            returnStmt.values = newValues
-        }
-        return super.process(returnStmt)
-    }
-
-
-    internal val anonymousVariablesFromHeap = mutableMapOf<String, Pair<LiteralValue, VarDecl>>()
-
-
-    override fun process(literalValue: LiteralValue): LiteralValue {
-        if(literalValue.heapId!=null && literalValue.parent !is VarDecl) {
-            // a literal value that's not declared as a variable, which refers to something on the heap.
-            // we need to introduce an auto-generated variable for this to be able to refer to the value!
-            val variable = VarDecl(VarDeclType.VAR, literalValue.type, false, null, false, "$autoHeapValuePrefix${literalValue.heapId}", literalValue, literalValue.position)
-            anonymousVariablesFromHeap[variable.name] = Pair(literalValue, variable)
-        }
-        return super.process(literalValue)
-    }
-
-    override fun process(addressOf: AddressOf): IExpression {
-        // register the scoped name of the referenced identifier
-        val variable= addressOf.identifier.targetVarDecl(namespace) ?: return addressOf
-        addressOf.scopedname = variable.scopedname
-        return super.process(addressOf)
-    }
-
-}
-
-internal const val autoHeapValuePrefix = "auto_heap_value_"

compiler/src/prog8/ast/AstRecursionChecker.kt

@@ -1,120 +0,0 @@
-package prog8.ast
-
-/**
- * Checks for the occurrence of recursive subroutine calls
- */
-
-fun Module.checkRecursion(namespace: INameScope) {
-    val checker = AstRecursionChecker(namespace)
-    this.process(checker)
-    printErrors(checker.result(), name)
-}
-
-
-private class DirectedGraph<VT> {
-    private val graph = mutableMapOf<VT, MutableSet<VT>>()
-    private var uniqueVertices = mutableSetOf<VT>()
-    val numVertices : Int
-        get() = uniqueVertices.size
-
-    fun add(from: VT, to: VT) {
-        var targets = graph[from]
-        if(targets==null) {
-            targets = mutableSetOf()
-            graph[from] = targets
-        }
-        targets.add(to)
-        uniqueVertices.add(from)
-        uniqueVertices.add(to)
-    }
-
-    fun print() {
-        println("#vertices: $numVertices")
-        graph.forEach { from, to ->
-            println("$from   CALLS:")
-            to.forEach { println("   $it") }
-        }
-        val cycle = checkForCycle()
-        if(cycle.isNotEmpty()) {
-            println("CYCLIC!  $cycle")
-        }
-    }
-
-    fun checkForCycle(): MutableList<VT> {
-        val visited = uniqueVertices.associate { it to false }.toMutableMap()
-        val recStack = uniqueVertices.associate { it to false }.toMutableMap()
-        val cycle = mutableListOf<VT>()
-        for(node in uniqueVertices) {
-            if(isCyclicUntil(node, visited, recStack, cycle))
-                return cycle
-        }
-        return mutableListOf()
-    }
-
-    private fun isCyclicUntil(node: VT,
-                              visited: MutableMap<VT, Boolean>,
-                              recStack: MutableMap<VT, Boolean>,
-                              cycleNodes: MutableList<VT>): Boolean {
-
-        if(recStack[node]==true) return true
-        if(visited[node]==true) return false
-
-        // mark current node as visited and add to recursion stack
-        visited[node] = true
-        recStack[node] = true
-
-        // recurse for all neighbours
-        val neighbors = graph[node]
-        if(neighbors!=null) {
-            for (neighbour in neighbors) {
-                if (isCyclicUntil(neighbour, visited, recStack, cycleNodes)) {
-                    cycleNodes.add(node)
-                    return true
-                }
-            }
-        }
-
-        // pop node from recursion stack
-        recStack[node] = false
-        return false
-    }
-}
-
-
-private class AstRecursionChecker(private val namespace: INameScope) : IAstProcessor {
-    private val callGraph = DirectedGraph<INameScope>()
-
-    fun result(): List<AstException> {
-        val cycle = callGraph.checkForCycle()
-        if(cycle.isEmpty())
-            return emptyList()
-        val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
-        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
-    }
-
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        val scope = functionCallStatement.definingScope()
-        val targetStatement = functionCallStatement.target.targetStatement(namespace)
-        if(targetStatement!=null) {
-            val targetScope = when (targetStatement) {
-                is Subroutine -> targetStatement
-                else -> targetStatement.definingScope()
-            }
-            callGraph.add(scope, targetScope)
-        }
-        return super.process(functionCallStatement)
-    }
-
-    override fun process(functionCall: FunctionCall): IExpression {
-        val scope = functionCall.definingScope()
-        val targetStatement = functionCall.target.targetStatement(namespace)
-        if(targetStatement!=null) {
-            val targetScope = when (targetStatement) {
-                is Subroutine -> targetStatement
-                else -> targetStatement.definingScope()
-            }
-            callGraph.add(scope, targetScope)
-        }
-        return super.process(functionCall)
-    }
-}

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -0,0 +1,456 @@
+package prog8.ast
+
+import prog8.ast.antlr.escape
+import prog8.ast.base.DataType
+import prog8.ast.base.NumericDatatypes
+import prog8.ast.base.StringDatatypes
+import prog8.ast.base.VarDeclType
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+import prog8.compiler.toHex
+
+class AstToSourceCode(val output: (text: String) -> Unit, val program: Program): IAstVisitor {
+    private var scopelevel = 0
+
+    private fun indent(s: String) = "    ".repeat(scopelevel) + s
+    private fun outputln(text: String) = output(text + "\n")
+    private fun outputlni(s: Any) = outputln(indent(s.toString()))
+    private fun outputi(s: Any) = output(indent(s.toString()))
+
+    override fun visit(program: Program) {
+        outputln("============= PROGRAM ${program.name} (FROM AST) ===============")
+        super.visit(program)
+        outputln("============= END PROGRAM ${program.name} (FROM AST) ===========")
+    }
+
+    override fun visit(module: Module) {
+        if(!module.isLibraryModule) {
+            outputln("; ----------- module: ${module.name} -----------")
+            super.visit(module)
+        }
+        else outputln("; library module skipped: ${module.name}")
+    }
+
+    override fun visit(block: Block) {
+        val addr = if(block.address!=null) block.address.toHex() else ""
+        outputln("~ ${block.name} $addr {")
+        scopelevel++
+        for(stmt in block.statements) {
+            outputi("")
+            stmt.accept(this)
+            output("\n")
+        }
+        scopelevel--
+        outputln("}\n")
+    }
+
+    override fun visit(expr: PrefixExpression) {
+        if(expr.operator.any { it.isLetter() })
+            output(" ${expr.operator} ")
+        else
+            output(expr.operator)
+        expr.expression.accept(this)
+    }
+
+    override fun visit(expr: BinaryExpression) {
+        expr.left.accept(this)
+        if(expr.operator.any { it.isLetter() })
+            output(" ${expr.operator} ")
+        else
+            output(expr.operator)
+        expr.right.accept(this)
+    }
+
+    override fun visit(directive: Directive) {
+        output("${directive.directive} ")
+        for(arg in directive.args) {
+            when {
+                arg.int!=null -> output(arg.int.toString())
+                arg.name!=null -> output(arg.name)
+                arg.str!=null -> output("\"${arg.str}\"")
+            }
+            if(arg!==directive.args.last())
+                output(",")
+        }
+        output("\n")
+    }
+
+    private fun datatypeString(dt: DataType): String {
+        return when(dt) {
+            in NumericDatatypes -> dt.toString().toLowerCase()
+            in StringDatatypes -> dt.toString().toLowerCase()
+            DataType.ARRAY_UB -> "ubyte["
+            DataType.ARRAY_B -> "byte["
+            DataType.ARRAY_UW -> "uword["
+            DataType.ARRAY_W -> "word["
+            DataType.ARRAY_F -> "float["
+            DataType.STRUCT -> ""       // the name of the struct is enough
+            else -> "?????2"
+        }
+    }
+
+    override fun visit(structDecl: StructDecl) {
+        outputln("struct ${structDecl.name} {")
+        scopelevel++
+        for(decl in structDecl.statements) {
+            outputi("")
+            decl.accept(this)
+            output("\n")
+        }
+        scopelevel--
+        outputlni("}")
+    }
+
+    override fun visit(decl: VarDecl) {
+        when(decl.type) {
+            VarDeclType.VAR -> {}
+            VarDeclType.CONST -> output("const ")
+            VarDeclType.MEMORY -> output("&")
+        }
+        output(decl.struct?.name ?: "")
+        output(datatypeString(decl.datatype))
+        if(decl.arraysize!=null) {
+            decl.arraysize!!.index.accept(this)
+        }
+        if(decl.isArray)
+            output("]")
+
+        if(decl.zeropage == ZeropageWish.REQUIRE_ZEROPAGE || decl.zeropage==ZeropageWish.PREFER_ZEROPAGE)
+            output(" @zp")
+        output(" ${decl.name} ")
+        if(decl.value!=null) {
+            output("= ")
+            decl.value?.accept(this)
+        }
+    }
+
+    override fun visit(subroutine: Subroutine) {
+        output("\n")
+        if(subroutine.isAsmSubroutine) {
+            outputi("asmsub ${subroutine.name} (")
+            for(param in subroutine.parameters.zip(subroutine.asmParameterRegisters)) {
+                val reg =
+                        when {
+                            true==param.second.stack -> "stack"
+                            param.second.registerOrPair!=null -> param.second.registerOrPair.toString()
+                            param.second.statusflag!=null -> param.second.statusflag.toString()
+                            else -> "?????1"
+                        }
+                output("${datatypeString(param.first.type)} ${param.first.name} @$reg")
+                if(param.first!==subroutine.parameters.last())
+                    output(", ")
+            }
+        }
+        else {
+            outputi("sub ${subroutine.name} (")
+            for(param in subroutine.parameters) {
+                output("${datatypeString(param.type)} ${param.name}")
+                if(param!==subroutine.parameters.last())
+                    output(", ")
+            }
+        }
+        output(") ")
+        if(subroutine.asmClobbers.isNotEmpty()) {
+            output("-> clobbers (")
+            val regs = subroutine.asmClobbers.toList().sorted()
+            for(r in regs) {
+                output(r.toString())
+                if(r!==regs.last())
+                    output(",")
+            }
+            output(") ")
+        }
+        if(subroutine.returntypes.any()) {
+            val rt = subroutine.returntypes.single()
+            output("-> ${datatypeString(rt)} ")
+        }
+        if(subroutine.asmAddress!=null)
+            outputln("= ${subroutine.asmAddress.toHex()}")
+        else {
+            outputln("{ ")
+            scopelevel++
+            outputStatements(subroutine.statements)
+            scopelevel--
+            outputi("}")
+        }
+    }
+
+    private fun outputStatements(statements: List<Statement>) {
+        for(stmt in statements) {
+            if(stmt is VarDecl && stmt.autogeneratedDontRemove)
+                continue    // skip autogenerated decls (to avoid generating a newline)
+            outputi("")
+            stmt.accept(this)
+            output("\n")
+        }
+    }
+
+    override fun visit(functionCall: FunctionCall) {
+        printout(functionCall as IFunctionCall)
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        printout(functionCallStatement as IFunctionCall)
+    }
+
+    private fun printout(call: IFunctionCall) {
+        call.target.accept(this)
+        output("(")
+        for(arg in call.arglist) {
+            arg.accept(this)
+            if(arg!==call.arglist.last())
+                output(", ")
+        }
+        output(")")
+    }
+
+    override fun visit(identifier: IdentifierReference) {
+        output(identifier.nameInSource.joinToString("."))
+    }
+
+    override fun visit(jump: Jump) {
+        output("goto ")
+        when {
+            jump.address!=null -> output(jump.address.toHex())
+            jump.generatedLabel!=null -> output(jump.generatedLabel)
+            jump.identifier!=null -> jump.identifier.accept(this)
+        }
+    }
+
+    override fun visit(ifStatement: IfStatement) {
+        output("if ")
+        ifStatement.condition.accept(this)
+        output(" ")
+        ifStatement.truepart.accept(this)
+        if(ifStatement.elsepart.statements.isNotEmpty()) {
+            output(" else ")
+            ifStatement.elsepart.accept(this)
+        }
+    }
+
+    override fun visit(branchStatement: BranchStatement) {
+        output("if_${branchStatement.condition.toString().toLowerCase()} ")
+        branchStatement.truepart.accept(this)
+        if(branchStatement.elsepart.statements.isNotEmpty()) {
+            output(" else ")
+            branchStatement.elsepart.accept(this)
+        }
+    }
+
+    override fun visit(range: RangeExpr) {
+        range.from.accept(this)
+        output(" to ")
+        range.to.accept(this)
+        output(" step ")
+        range.step.accept(this)
+        output(" ")
+    }
+
+    override fun visit(label: Label) {
+        output("\n")
+        output("${label.name}:")
+    }
+
+    override fun visit(numLiteral: NumericLiteralValue) {
+        output(numLiteral.number.toString())
+    }
+
+    override fun visit(refLiteral: ReferenceLiteralValue) {
+        when {
+            refLiteral.isString -> output("\"${escape(refLiteral.str!!)}\"")
+            refLiteral.isArray -> {
+                if(refLiteral.array!=null) {
+                    outputListMembers(refLiteral.array.asSequence(), '[', ']')
+                }
+            }
+        }
+    }
+
+    private fun outputListMembers(array: Sequence<Expression>, openchar: Char, closechar: Char) {
+        var counter = 0
+        output(openchar.toString())
+        scopelevel++
+        for (v in array) {
+            v.accept(this)
+            if (v !== array.last())
+                output(", ")
+            counter++
+            if (counter > 16) {
+                outputln("")
+                outputi("")
+                counter = 0
+            }
+        }
+        scopelevel--
+        output(closechar.toString())
+    }
+
+    override fun visit(assignment: Assignment) {
+        if(assignment is VariableInitializationAssignment) {
+            val targetVar = assignment.target.identifier?.targetVarDecl(program.namespace)
+            if(targetVar?.struct != null) {
+                // skip STRUCT init assignments
+                return
+            }
+        }
+
+        assignment.target.accept(this)
+        if (assignment.aug_op != null)
+            output(" ${assignment.aug_op} ")
+        else
+            output(" = ")
+        assignment.value.accept(this)
+    }
+
+    override fun visit(postIncrDecr: PostIncrDecr) {
+        postIncrDecr.target.accept(this)
+        output(postIncrDecr.operator)
+    }
+
+    override fun visit(contStmt: Continue) {
+        output("continue")
+    }
+
+    override fun visit(breakStmt: Break) {
+        output("break")
+    }
+
+    override fun visit(forLoop: ForLoop) {
+        output("for ")
+        if(forLoop.decltype!=null) {
+            output(datatypeString(forLoop.decltype))
+            if (forLoop.zeropage==ZeropageWish.REQUIRE_ZEROPAGE || forLoop.zeropage==ZeropageWish.PREFER_ZEROPAGE)
+                output(" @zp ")
+            else
+                output(" ")
+        }
+        if(forLoop.loopRegister!=null)
+            output(forLoop.loopRegister.toString())
+        else
+            forLoop.loopVar!!.accept(this)
+        output(" in ")
+        forLoop.iterable.accept(this)
+        output(" ")
+        forLoop.body.accept(this)
+    }
+
+    override fun visit(whileLoop: WhileLoop) {
+        output("while ")
+        whileLoop.condition.accept(this)
+        output(" ")
+        whileLoop.body.accept(this)
+    }
+
+    override fun visit(repeatLoop: RepeatLoop) {
+        output("repeat ")
+        repeatLoop.body.accept(this)
+        output(" until ")
+        repeatLoop.untilCondition.accept(this)
+    }
+
+    override fun visit(returnStmt: Return) {
+        output("return ")
+        returnStmt.value?.accept(this)
+    }
+
+    override fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
+        arrayIndexedExpression.identifier.accept(this)
+        output("[")
+        arrayIndexedExpression.arrayspec.index.accept(this)
+        output("]")
+    }
+
+    override fun visit(assignTarget: AssignTarget) {
+        if(assignTarget.register!=null)
+            output(assignTarget.register.toString())
+        else {
+            assignTarget.memoryAddress?.accept(this)
+            assignTarget.identifier?.accept(this)
+        }
+        assignTarget.arrayindexed?.accept(this)
+    }
+
+    override fun visit(scope: AnonymousScope) {
+        outputln("{")
+        scopelevel++
+        outputStatements(scope.statements)
+        scopelevel--
+        outputi("}")
+    }
+
+    override fun visit(typecast: TypecastExpression) {
+        output("(")
+        typecast.expression.accept(this)
+        output(" as ${datatypeString(typecast.type)}) ")
+    }
+
+    override fun visit(memread: DirectMemoryRead) {
+        output("@(")
+        memread.addressExpression.accept(this)
+        output(")")
+    }
+
+    override fun visit(memwrite: DirectMemoryWrite) {
+        output("@(")
+        memwrite.addressExpression.accept(this)
+        output(")")
+    }
+
+    override fun visit(addressOf: AddressOf) {
+        output("&")
+        addressOf.identifier.accept(this)
+    }
+
+    override fun visit(inlineAssembly: InlineAssembly) {
+        outputlni("%asm {{")
+        outputln(inlineAssembly.assembly)
+        outputlni("}}")
+    }
+
+    override fun visit(registerExpr: RegisterExpr) {
+        output(registerExpr.register.toString())
+    }
+
+    override fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
+        output(builtinFunctionStatementPlaceholder.name)
+    }
+
+    override fun visit(whenStatement: WhenStatement) {
+        output("when ")
+        whenStatement.condition.accept(this)
+        outputln(" {")
+        scopelevel++
+        whenStatement.choices.forEach { it.accept(this) }
+        scopelevel--
+        outputlni("}")
+    }
+
+    override fun visit(whenChoice: WhenChoice) {
+        val choiceValues = whenChoice.values
+        if(choiceValues==null)
+            outputi("else -> ")
+        else {
+            outputi("")
+            for(value in choiceValues) {
+                value.accept(this)
+                if(value !== choiceValues.last())
+                    output(",")
+            }
+            output(" -> ")
+        }
+        if(whenChoice.statements.statements.size==1)
+            whenChoice.statements.statements.single().accept(this)
+        else
+            whenChoice.statements.accept(this)
+        outputln("")
+    }
+
+    override fun visit(structLv: StructLiteralValue) {
+        outputListMembers(structLv.values.asSequence(), '{', '}')
+    }
+
+    override fun visit(nopStatement: NopStatement) {
+        output("; NOP @ ${nopStatement.position}  $nopStatement")
+    }
+}

compiler/src/prog8/ast/AstToplevel.kt

@@ -0,0 +1,263 @@
+package prog8.ast
+
+import prog8.ast.base.*
+import prog8.ast.expressions.Expression
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.statements.*
+import prog8.compiler.HeapValues
+import prog8.functions.BuiltinFunctions
+import java.nio.file.Path
+
+
+interface Node {
+    val position: Position
+    var parent: Node             // will be linked correctly later (late init)
+    fun linkParents(parent: Node)
+
+    fun definingModule(): Module {
+        if(this is Module)
+            return this
+        return findParentNode<Module>(this)!!
+    }
+
+    fun definingSubroutine(): Subroutine?  = findParentNode<Subroutine>(this)
+
+    fun definingScope(): INameScope {
+        val scope = findParentNode<INameScope>(this)
+        if(scope!=null) {
+            return scope
+        }
+        if(this is Label && this.name.startsWith("builtin::")) {
+            return BuiltinFunctionScopePlaceholder
+        }
+        if(this is GlobalNamespace)
+            return this
+        throw FatalAstException("scope missing from $this")
+    }
+}
+
+interface IFunctionCall {
+    var target: IdentifierReference
+    var arglist: MutableList<Expression>
+}
+
+interface INameScope {
+    val name: String
+    val position: Position
+    val statements: MutableList<Statement>
+    val parent: Node
+
+    fun linkParents(parent: Node)
+
+    fun subScopes(): Map<String, INameScope> {
+        val subscopes = mutableMapOf<String, INameScope>()
+        for(stmt in statements) {
+            when(stmt) {
+                // NOTE: if other nodes are introduced that are a scope, or contain subscopes, they must be added here!
+                is ForLoop -> subscopes[stmt.body.name] = stmt.body
+                is RepeatLoop -> subscopes[stmt.body.name] = stmt.body
+                is WhileLoop -> subscopes[stmt.body.name] = stmt.body
+                is BranchStatement -> {
+                    subscopes[stmt.truepart.name] = stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars())
+                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                }
+                is IfStatement -> {
+                    subscopes[stmt.truepart.name] = stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars())
+                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                }
+                is WhenStatement -> {
+                    stmt.choices.forEach { subscopes[it.statements.name] = it.statements }
+                }
+                is INameScope -> subscopes[stmt.name] = stmt
+                else -> {}
+            }
+        }
+        return subscopes
+    }
+
+    fun getLabelOrVariable(name: String): Statement? {
+        // this is called A LOT and could perhaps be optimized a bit more,
+        // but adding a memoization cache didn't make much of a practical runtime difference
+        for (stmt in statements) {
+            if (stmt is VarDecl && stmt.name==name) return stmt
+            if (stmt is Label && stmt.name==name) return stmt
+            if (stmt is AnonymousScope) {
+                val sub = stmt.getLabelOrVariable(name)
+                if(sub!=null)
+                    return sub
+            }
+        }
+        return null
+    }
+
+    fun allDefinedSymbols(): List<Pair<String, Statement>>  {
+        return statements.mapNotNull {
+            when (it) {
+                is Label -> it.name to it
+                is VarDecl -> it.name to it
+                is Subroutine -> it.name to it
+                is Block -> it.name to it
+                else -> null
+            }
+        }
+    }
+
+    fun lookup(scopedName: List<String>, localContext: Node) : Statement? {
+        if(scopedName.size>1) {
+            // a scoped name can a) refer to a member of a struct, or b) refer to a name in another module.
+            // try the struct first.
+            val thing = lookup(scopedName.dropLast(1), localContext) as? VarDecl
+            val struct = thing?.struct
+            if (struct != null) {
+                if(struct.statements.any { (it as VarDecl).name == scopedName.last()}) {
+                    // return ref to the mangled name variable
+                    val mangled = mangledStructMemberName(thing.name, scopedName.last())
+                    return thing.definingScope().getLabelOrVariable(mangled)
+                }
+            }
+
+            // it's a qualified name, look it up from the root of the module's namespace (consider all modules in the program)
+            for(module in localContext.definingModule().program.modules) {
+                var scope: INameScope? = module
+                for(name in scopedName.dropLast(1)) {
+                    scope = scope?.subScopes()?.get(name)
+                    if(scope==null)
+                        break
+                }
+                if(scope!=null) {
+                    val result = scope.getLabelOrVariable(scopedName.last())
+                    if(result!=null)
+                        return result
+                    return scope.subScopes()[scopedName.last()] as Statement?
+                }
+            }
+            return null
+        } else {
+            // unqualified name, find the scope the localContext is in, look in that first
+            var statementScope = localContext
+            while(statementScope !is ParentSentinel) {
+                val localScope = statementScope.definingScope()
+                val result = localScope.getLabelOrVariable(scopedName[0])
+                if (result != null)
+                    return result
+                val subscope = localScope.subScopes()[scopedName[0]] as Statement?
+                if (subscope != null)
+                    return subscope
+                // not found in this scope, look one higher up
+                statementScope = statementScope.parent
+            }
+            return null
+        }
+    }
+
+    fun containsCodeOrVars() = statements.any { it !is Directive || it.directive == "%asminclude" || it.directive == "%asm"}
+    fun containsNoCodeNorVars() = !containsCodeOrVars()
+
+    fun remove(stmt: Statement) {
+        if(!statements.remove(stmt))
+            throw FatalAstException("stmt to remove wasn't found in scope")
+    }
+}
+
+
+/*********** Everything starts from here, the Program; zero or more modules *************/
+
+class Program(val name: String, val modules: MutableList<Module>) {
+    val namespace = GlobalNamespace(modules)
+    val heap = HeapValues()
+
+    val definedLoadAddress: Int
+        get() = modules.first().loadAddress
+
+    var actualLoadAddress: Int = 0
+
+    fun entrypoint(): Subroutine? {
+        val mainBlocks = modules.flatMap { it.statements }.filter { b -> b is Block && b.name=="main" }.map { it as Block }
+        if(mainBlocks.size > 1)
+            throw FatalAstException("more than one 'main' block")
+        return if(mainBlocks.isEmpty()) {
+            null
+        } else {
+            mainBlocks[0].subScopes()["start"] as Subroutine?
+        }
+    }
+
+    fun allBlocks(): List<Block> = modules.flatMap { it.statements.filterIsInstance<Block>() }
+}
+
+class Module(override val name: String,
+             override var statements: MutableList<Statement>,
+             override val position: Position,
+             val isLibraryModule: Boolean,
+             val source: Path) : Node, INameScope {
+    override lateinit var parent: Node
+    lateinit var program: Program
+    val importedBy = mutableListOf<Module>()
+    val imports = mutableSetOf<Module>()
+
+    var loadAddress: Int = 0        // can be set with the %address directive
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach {it.linkParents(this)}
+    }
+
+    override fun definingScope(): INameScope = program.namespace
+
+    override fun toString() = "Module(name=$name, pos=$position, lib=$isLibraryModule)"
+}
+
+class GlobalNamespace(val modules: List<Module>): Node, INameScope {
+    override val name = "<<<global>>>"
+    override val position = Position("<<<global>>>", 0, 0, 0)
+    override val statements = mutableListOf<Statement>()
+    override var parent: Node = ParentSentinel
+
+    override fun linkParents(parent: Node) {
+        modules.forEach { it.linkParents(this) }
+    }
+
+    override fun lookup(scopedName: List<String>, localContext: Node): Statement? {
+        if (scopedName.size == 1 && scopedName[0] in BuiltinFunctions) {
+            // builtin functions always exist, return a dummy localContext for them
+            val builtinPlaceholder = Label("builtin::${scopedName.last()}", localContext.position)
+            builtinPlaceholder.parent = ParentSentinel
+            return builtinPlaceholder
+        }
+
+        if(scopedName.size>1) {
+            // a scoped name can a) refer to a member of a struct, or b) refer to a name in another module.
+            // try the struct first.
+            val thing = lookup(scopedName.dropLast(1), localContext) as? VarDecl
+            val struct = thing?.struct
+            if (struct != null) {
+                if(struct.statements.any { (it as VarDecl).name == scopedName.last()}) {
+                    // return ref to the mangled name variable
+                    val mangled = mangledStructMemberName(thing.name, scopedName.last())
+                    return thing.definingScope().getLabelOrVariable(mangled)
+                }
+            }
+        }
+
+        val stmt = localContext.definingModule().lookup(scopedName, localContext)
+        return when (stmt) {
+            is Label, is VarDecl, is Block, is Subroutine -> stmt
+            null -> null
+            else -> throw NameError("wrong identifier target: $stmt", stmt.position)
+        }
+    }
+}
+
+object BuiltinFunctionScopePlaceholder : INameScope {
+    override val name = "<<builtin-functions-scope-placeholder>>"
+    override val position = Position("<<placeholder>>", 0, 0, 0)
+    override var statements = mutableListOf<Statement>()
+    override var parent: Node = ParentSentinel
+    override fun linkParents(parent: Node) {}
+}
+
+
+// prefix for struct member variables
+internal fun mangledStructMemberName(varName: String, memberName: String) = "prog8struct_${varName}_$memberName"

compiler/src/prog8/ast/StmtReorderer.kt

@@ -1,326 +0,0 @@
-package prog8.ast
-
-import prog8.compiler.HeapValues
-
-fun Module.reorderStatements(namespace: INameScope, heap: HeapValues) {
-    val initvalueCreator = VarInitValueAndAddressOfCreator(namespace)
-    this.process(initvalueCreator)
-
-    val checker = StatementReorderer(namespace, heap)
-    this.process(checker)
-}
-
-const val initvarsSubName="prog8_init_vars"    // the name of the subroutine that should be called for every block to initialize its variables
-
-
-private class StatementReorderer(private val namespace: INameScope, private val heap: HeapValues): IAstProcessor {
-    // Reorders the statements in a way the compiler needs.
-    // - 'main' block must be the very first statement UNLESS it has an address set.
-    // - blocks are ordered by address, where blocks without address are put at the end.
-    // - in every scope:
-    //      -- the directives '%output', '%launcher', '%zeropage', '%zpreserved', '%address' and '%option' will come first.
-    //      -- all vardecls then follow.
-    //      -- the remaining statements then follow in their original order.
-    //
-    // - the 'start' subroutine in the 'main' block will be moved to the top immediately following the directives.
-    // - all other subroutines will be moved to the end of their block.
-
-    private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%option")
-
-    override fun process(module: Module) {
-        super.process(module)
-
-        val (blocks, other) = module.statements.partition { it is Block }
-        module.statements = other.asSequence().plus(blocks.sortedBy { (it as Block).address ?: Int.MAX_VALUE }).toMutableList()
-
-        // make sure user-defined blocks come BEFORE library blocks, and move the "main" block to the top of everything
-        val nonLibraryBlocks = module.statements.withIndex()
-                .filter { it.value is Block && !(it.value as Block).isInLibrary }
-                .map { it.index to it.value }
-                .reversed()
-        for(nonLibBlock in nonLibraryBlocks)
-            module.statements.removeAt(nonLibBlock.first)
-        for(nonLibBlock in nonLibraryBlocks)
-            module.statements.add(0, nonLibBlock.second)
-        val mainBlock = module.statements.single { it is Block && it.name=="main" }
-        if((mainBlock as Block).address==null) {
-            module.statements.remove(mainBlock)
-            module.statements.add(0, mainBlock)
-        }
-
-        val varDecls = module.statements.filterIsInstance<VarDecl>()
-        module.statements.removeAll(varDecls)
-        module.statements.addAll(0, varDecls)
-
-        val directives = module.statements.filter {it is Directive && it.directive in directivesToMove}
-        module.statements.removeAll(directives)
-        module.statements.addAll(0, directives)
-
-        sortConstantAssignments(module.statements)
-    }
-
-    override fun process(block: Block): IStatement {
-
-        val subroutines = block.statements.filterIsInstance<Subroutine>()
-        var numSubroutinesAtEnd = 0
-        // move all subroutines to the end of the block
-        for (subroutine in subroutines) {
-            if(subroutine.name!="start" || block.name!="main") {
-                block.statements.remove(subroutine)
-                block.statements.add(subroutine)
-            }
-            numSubroutinesAtEnd++
-        }
-        // move the "start" subroutine to the top
-        if(block.name=="main") {
-            block.statements.singleOrNull { it is Subroutine && it.name == "start" } ?.let {
-                block.statements.remove(it)
-                block.statements.add(0, it)
-                numSubroutinesAtEnd--
-            }
-        }
-
-        // make sure there is a 'return' in front of the first subroutine
-        // (if it isn't the first statement in the block itself, and isn't the program's entrypoint)
-        if(numSubroutinesAtEnd>0 && block.statements.size > (numSubroutinesAtEnd+1)) {
-            val firstSub = block.statements[block.statements.size - numSubroutinesAtEnd] as Subroutine
-            if(firstSub.name != "start" && block.name != "main") {
-                val stmtBeforeFirstSub = block.statements[block.statements.size - numSubroutinesAtEnd - 1]
-                if (stmtBeforeFirstSub !is Return
-                        && stmtBeforeFirstSub !is Jump
-                        && stmtBeforeFirstSub !is Subroutine
-                        && stmtBeforeFirstSub !is BuiltinFunctionStatementPlaceholder) {
-                    val ret = Return(emptyList(), stmtBeforeFirstSub.position)
-                    ret.linkParents(block)
-                    block.statements.add(block.statements.size - numSubroutinesAtEnd, ret)
-                }
-            }
-        }
-
-        val varDecls = block.statements.filter { it is VarDecl }
-        block.statements.removeAll(varDecls)
-        block.statements.addAll(0, varDecls)
-        val directives = block.statements.filter {it is Directive && it.directive in directivesToMove}
-        block.statements.removeAll(directives)
-        block.statements.addAll(0, directives)
-
-        sortConstantAssignments(block.statements)
-
-        val varInits = block.statements.withIndex().filter { it.value is VariableInitializationAssignment }
-        if(varInits.isNotEmpty()) {
-            val statements = varInits.map{it.value}.toMutableList()
-            val varInitSub = Subroutine(initvarsSubName, emptyList(), emptyList(), emptyList(), emptyList(),
-                    emptySet(), null, false, statements, block.position)
-            varInitSub.linkParents(block)
-            block.statements.add(varInitSub)
-
-            // remove the varinits from the block's statements
-            for(index in varInits.map{it.index}.reversed())
-                block.statements.removeAt(index)
-        }
-
-        return super.process(block)
-    }
-
-    override fun process(subroutine: Subroutine): IStatement {
-        super.process(subroutine)
-
-        sortConstantAssignments(subroutine.statements)
-
-        val varDecls = subroutine.statements.filterIsInstance<VarDecl>()
-        subroutine.statements.removeAll(varDecls)
-        subroutine.statements.addAll(0, varDecls)
-        val directives = subroutine.statements.filter {it is Directive && it.directive in directivesToMove}
-        subroutine.statements.removeAll(directives)
-        subroutine.statements.addAll(0, directives)
-
-        if(subroutine.returntypes.isEmpty()) {
-            // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
-            // and if an assembly block doesn't contain a rts/rti
-            if(subroutine.asmAddress==null && subroutine.amountOfRtsInAsm()==0) {
-                if (subroutine.statements.lastOrNull {it !is VarDecl} !is Return) {
-                    val returnStmt = Return(emptyList(), subroutine.position)
-                    returnStmt.linkParents(subroutine)
-                    subroutine.statements.add(returnStmt)
-                }
-            }
-        }
-
-        return subroutine
-    }
-
-    override fun process(scope: AnonymousScope): AnonymousScope {
-        scope.statements = scope.statements.map { it.process(this)}.toMutableList()
-        sortConstantAssignments(scope.statements)
-        return scope
-    }
-
-    override fun process(decl: VarDecl): IStatement {
-        if(decl.arraysize==null) {
-            val array = decl.value as? LiteralValue
-            if(array!=null && array.isArray) {
-                val size = heap.get(array.heapId!!).arraysize
-                decl.arraysize = ArrayIndex(LiteralValue.optimalInteger(size, decl.position), decl.position)
-            }
-        }
-        return super.process(decl)
-    }
-
-    private fun sortConstantAssignments(statements: MutableList<IStatement>) {
-        // sort assignments by datatype and value, so multiple initializations with the same value can be optimized (to load the value just once)
-        val result = mutableListOf<IStatement>()
-        val stmtIter = statements.iterator()
-        for(stmt in stmtIter) {
-            if(stmt is Assignment && !stmt.targets.any { it.isMemoryMapped(namespace) }) {
-                val constval = stmt.value.constValue(namespace, heap)
-                if(constval!=null) {
-                    val (sorted, trailing) = sortConstantAssignmentSequence(stmt, stmtIter)
-                    result.addAll(sorted)
-                    if(trailing!=null)
-                        result.add(trailing)
-                }
-                else
-                    result.add(stmt)
-            }
-            else
-                result.add(stmt)
-        }
-        statements.clear()
-        statements.addAll(result)
-    }
-
-    private fun sortConstantAssignmentSequence(first: Assignment, stmtIter: MutableIterator<IStatement>): Pair<List<Assignment>, IStatement?> {
-        val sequence= mutableListOf(first)
-        var trailing: IStatement? = null
-        while(stmtIter.hasNext()) {
-            val next = stmtIter.next()
-            if(next is Assignment) {
-                val constValue = next.value.constValue(namespace, heap)
-                if(constValue==null) {
-                    trailing = next
-                    break
-                }
-                sequence.add(next)
-            }
-            else {
-                trailing=next
-                break
-            }
-        }
-        val sorted = sequence.sortedWith(compareBy({it.value.resultingDatatype(namespace, heap)}, {it.singleTarget?.shortString(true)}))
-        return Pair(sorted, trailing)
-    }
-
-}
-
-
-private class VarInitValueAndAddressOfCreator(private val namespace: INameScope): IAstProcessor {
-    // Replace the var decl with an assignment and add a new vardecl with the default constant value.
-    // This makes sure the variables get reset to the intended value on a next run of the program.
-    // Variable decls without a value don't get this treatment, which means they retain the last
-    // value they had when restarting the program.
-    // This is done in a separate step because it interferes with the namespace lookup of symbols
-    // in other ast processors.
-
-    // Also takes care to insert AddressOf (&) expression where required (string params to a UWORD function param etc).
-
-
-    private val vardeclsToAdd = mutableMapOf<INameScope, MutableMap<String, VarDecl>>()
-
-    override fun process(module: Module) {
-        super.process(module)
-
-        // add any new vardecls to the various scopes
-        for(decl in vardeclsToAdd)
-            for(d in decl.value) {
-                d.value.linkParents(decl.key as Node)
-                decl.key.statements.add(0, d.value)
-            }
-    }
-
-    override fun process(decl: VarDecl): IStatement {
-        super.process(decl)
-        if(decl.type!=VarDeclType.VAR || decl.value==null)
-            return decl
-
-        if(decl.datatype in NumericDatatypes) {
-            val scope = decl.definingScope()
-            addVarDecl(scope, decl.asDefaultValueDecl(null))
-            val declvalue = decl.value!!
-            val value =
-                    if(declvalue is LiteralValue) {
-                        val converted = declvalue.intoDatatype(decl.datatype)
-                        converted ?: declvalue
-                    }
-                    else
-                        declvalue
-            return VariableInitializationAssignment(
-                    AssignTarget(null, IdentifierReference(decl.scopedname.split("."), decl.position), null, null, decl.position),
-                    null,
-                    value,
-                    decl.position
-            )
-        }
-        return decl
-    }
-
-    override fun process(functionCall: FunctionCall): IExpression {
-        val targetStatement = functionCall.target.targetSubroutine(namespace)
-        if(targetStatement!=null) {
-            var node: Node = functionCall
-            while(node !is IStatement)
-                node=node.parent
-            addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, node)
-        }
-        return functionCall
-    }
-
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        val targetStatement = functionCallStatement.target.targetSubroutine(namespace)
-        if(targetStatement!=null)
-            addAddressOfExprIfNeeded(targetStatement, functionCallStatement.arglist, functionCallStatement)
-        return functionCallStatement
-    }
-
-    private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<IExpression>, parent: IStatement) {
-        // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
-        for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
-            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) {
-                if(argparam.second is AddressOf)
-                    continue
-                val idref = argparam.second as? IdentifierReference
-                val strvalue = argparam.second as? LiteralValue
-                if(idref!=null) {
-                    val variable = idref.targetVarDecl(namespace)
-                    if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) {
-                        val pointerExpr = AddressOf(idref, idref.position)
-                        pointerExpr.scopedname = parent.makeScopedName(idref.nameInSource.single())
-                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                        arglist[argparam.first.index] = pointerExpr
-                    }
-                }
-                else if(strvalue!=null) {
-                    if(strvalue.isString) {
-                        // replace the argument with &autovar
-                        val autoVarName = "$autoHeapValuePrefix${strvalue.heapId}"
-                        val autoHeapvarRef = IdentifierReference(listOf(autoVarName), strvalue.position)
-                        val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
-                        pointerExpr.scopedname = parent.makeScopedName(autoVarName)
-                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                        arglist[argparam.first.index] = pointerExpr
-                        // add a vardecl so that the autovar can be resolved in later lookups
-                        val variable = VarDecl(VarDeclType.VAR, strvalue.type, false, null, false, autoVarName, strvalue, strvalue.position)
-                        addVarDecl(strvalue.definingScope(), variable)
-                    }
-                }
-            }
-        }
-    }
-
-    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
-        if(scope !in vardeclsToAdd)
-            vardeclsToAdd[scope] = mutableMapOf()
-        vardeclsToAdd.getValue(scope)[variable.name]=variable
-    }
-
-}

compiler/src/prog8/ast/antlr/Antr2Kotlin.kt

@@ -0,0 +1,646 @@
+package prog8.ast.antlr
+
+import org.antlr.v4.runtime.IntStream
+import org.antlr.v4.runtime.ParserRuleContext
+import org.antlr.v4.runtime.tree.TerminalNode
+import prog8.ast.Module
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.compiler.target.c64.Petscii
+import prog8.parser.CustomLexer
+import prog8.parser.prog8Parser
+import java.io.CharConversionException
+import java.io.File
+import java.nio.file.Path
+
+
+/***************** Antlr Extension methods to create AST ****************/
+
+private data class NumericLiteral(val number: Number, val datatype: DataType)
+
+
+fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
+    val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
+    return Module(nameWithoutSuffix, modulestatement().asSequence().map { it.toAst(isLibrary) }.toMutableList(), toPosition(), isLibrary, source)
+}
+
+
+private fun ParserRuleContext.toPosition() : Position {
+    val customTokensource = this.start.tokenSource as? CustomLexer
+    val filename =
+            when {
+                customTokensource!=null -> customTokensource.modulePath.fileName.toString()
+                start.tokenSource.sourceName == IntStream.UNKNOWN_SOURCE_NAME -> "@internal@"
+                else -> File(start.inputStream.sourceName).name
+            }
+    // note: be ware of TAB characters in the source text, they count as 1 column...
+    return Position(filename, start.line, start.charPositionInLine, stop.charPositionInLine + stop.text.length)
+}
+
+
+private fun prog8Parser.ModulestatementContext.toAst(isInLibrary: Boolean) : Statement {
+    val directive = directive()?.toAst()
+    if(directive!=null) return directive
+
+    val block = block()?.toAst(isInLibrary)
+    if(block!=null) return block
+
+    throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : Statement =
+        Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), statement_block().toAst(), isInLibrary, toPosition())
+
+
+private fun prog8Parser.Statement_blockContext.toAst(): MutableList<Statement> =
+        statement().asSequence().map { it.toAst() }.toMutableList()
+
+
+private fun prog8Parser.StatementContext.toAst() : Statement {
+    vardecl()?.let { return it.toAst() }
+
+    varinitializer()?.let {
+        val vd = it.vardecl()
+        return VarDecl(
+                VarDeclType.VAR,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                null,
+                it.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                it.toPosition()
+        )
+    }
+
+    structvarinitializer()?.let {
+        val vd = it.structvardecl()
+        return VarDecl(
+                VarDeclType.VAR,
+                DataType.STRUCT,
+                ZeropageWish.NOT_IN_ZEROPAGE,
+                null,
+                vd.varname.text,
+                vd.structname.text,
+                it.expression().toAst(),
+                isArray = false,
+                autogeneratedDontRemove = false,
+                position = it.toPosition()
+        )
+    }
+
+    structvardecl()?.let {
+        return VarDecl(
+                VarDeclType.VAR,
+                DataType.STRUCT,
+                ZeropageWish.NOT_IN_ZEROPAGE,
+                null,
+                it.varname.text,
+                it.structname.text,
+                null,
+                isArray = false,
+                autogeneratedDontRemove = false,
+                position = it.toPosition()
+        )
+    }
+
+    constdecl()?.let {
+        val cvarinit = it.varinitializer()
+        val vd = cvarinit.vardecl()
+        return VarDecl(
+                VarDeclType.CONST,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                null,
+                cvarinit.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                cvarinit.toPosition()
+        )
+    }
+
+    memoryvardecl()?.let {
+        val mvarinit = it.varinitializer()
+        val vd = mvarinit.vardecl()
+        return VarDecl(
+                VarDeclType.MEMORY,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                null,
+                mvarinit.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                mvarinit.toPosition()
+        )
+    }
+
+    assignment()?.let {
+        return Assignment(it.assign_target().toAst(), null, it.expression().toAst(), it.toPosition())
+    }
+
+    augassignment()?.let {
+        return Assignment(it.assign_target().toAst(),
+                it.operator.text,
+                it.expression().toAst(),
+                it.toPosition())
+    }
+
+    postincrdecr()?.let {
+        return PostIncrDecr(it.assign_target().toAst(), it.operator.text, it.toPosition())
+    }
+
+    val directive = directive()?.toAst()
+    if(directive!=null) return directive
+
+    val label = labeldef()?.toAst()
+    if(label!=null) return label
+
+    val jump = unconditionaljump()?.toAst()
+    if(jump!=null) return jump
+
+    val fcall = functioncall_stmt()?.toAst()
+    if(fcall!=null) return fcall
+
+    val ifstmt = if_stmt()?.toAst()
+    if(ifstmt!=null) return ifstmt
+
+    val returnstmt = returnstmt()?.toAst()
+    if(returnstmt!=null) return returnstmt
+
+    val sub = subroutine()?.toAst()
+    if(sub!=null) return sub
+
+    val asm = inlineasm()?.toAst()
+    if(asm!=null) return asm
+
+    val branchstmt = branch_stmt()?.toAst()
+    if(branchstmt!=null) return branchstmt
+
+    val forloop = forloop()?.toAst()
+    if(forloop!=null) return forloop
+
+    val repeatloop = repeatloop()?.toAst()
+    if(repeatloop!=null) return repeatloop
+
+    val whileloop = whileloop()?.toAst()
+    if(whileloop!=null) return whileloop
+
+    val breakstmt = breakstmt()?.toAst()
+    if(breakstmt!=null) return breakstmt
+
+    val continuestmt = continuestmt()?.toAst()
+    if(continuestmt!=null) return continuestmt
+
+    val asmsubstmt = asmsubroutine()?.toAst()
+    if(asmsubstmt!=null) return asmsubstmt
+
+    val whenstmt = whenstmt()?.toAst()
+    if(whenstmt!=null) return whenstmt
+
+    structdecl()?.let {
+        return StructDecl(it.identifier().text,
+                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
+                toPosition())
+    }
+
+    throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
+}
+
+private fun prog8Parser.AsmsubroutineContext.toAst(): Statement {
+    val name = identifier().text
+    val address = asmsub_address()?.address?.toAst()?.number?.toInt()
+    val params = asmsub_params()?.toAst() ?: emptyList()
+    val returns = asmsub_returns()?.toAst() ?: emptyList()
+    val normalParameters = params.map { SubroutineParameter(it.name, it.type, it.position) }
+    val normalReturnvalues = returns.map { it.type }
+    val paramRegisters = params.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
+    val returnRegisters = returns.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
+    val clobbers = asmsub_clobbers()?.clobber()?.toAst() ?: emptySet()
+    val statements = statement_block()?.toAst() ?: mutableListOf()
+    return Subroutine(name, normalParameters, normalReturnvalues,
+            paramRegisters, returnRegisters, clobbers, address, true, statements, toPosition())
+}
+
+private class AsmSubroutineParameter(name: String,
+                                     type: DataType,
+                                     val registerOrPair: RegisterOrPair?,
+                                     val statusflag: Statusflag?,
+                                     val stack: Boolean,
+                                     position: Position) : SubroutineParameter(name, type, position)
+
+private class AsmSubroutineReturn(val type: DataType,
+                                  val registerOrPair: RegisterOrPair?,
+                                  val statusflag: Statusflag?,
+                                  val stack: Boolean,
+                                  val position: Position)
+
+private fun prog8Parser.ClobberContext.toAst(): Set<Register>
+        = this.register().asSequence().map { it.toAst() }.toSet()
+
+
+private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
+        = asmsub_return().map { AsmSubroutineReturn(it.datatype().toAst(), it.registerorpair()?.toAst(), it.statusregister()?.toAst(), !it.stack?.text.isNullOrEmpty(), toPosition()) }
+
+private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>
+        = asmsub_param().map {
+    val vardecl = it.vardecl()
+    val datatype = vardecl.datatype()?.toAst() ?: DataType.STRUCT
+    AsmSubroutineParameter(vardecl.varname.text, datatype,
+            it.registerorpair()?.toAst(),
+            it.statusregister()?.toAst(),
+            !it.stack?.text.isNullOrEmpty(), toPosition())
+}
+
+
+private fun prog8Parser.StatusregisterContext.toAst() = Statusflag.valueOf(text)
+
+
+private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
+    val location = scoped_identifier().toAst()
+    return if(expression_list() == null)
+        FunctionCallStatement(location, mutableListOf(), toPosition())
+    else
+        FunctionCallStatement(location, expression_list().toAst().toMutableList(), toPosition())
+}
+
+
+private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
+    val location = scoped_identifier().toAst()
+    return if(expression_list() == null)
+        FunctionCall(location, mutableListOf(), toPosition())
+    else
+        FunctionCall(location, expression_list().toAst().toMutableList(), toPosition())
+}
+
+
+private fun prog8Parser.InlineasmContext.toAst() =
+        InlineAssembly(INLINEASMBLOCK().text, toPosition())
+
+
+private fun prog8Parser.ReturnstmtContext.toAst() : Return {
+    return Return(expression()?.toAst(), toPosition())
+}
+
+private fun prog8Parser.UnconditionaljumpContext.toAst(): Jump {
+    val address = integerliteral()?.toAst()?.number?.toInt()
+    val identifier = scoped_identifier()?.toAst()
+    return Jump(address, identifier, null, toPosition())
+}
+
+
+private fun prog8Parser.LabeldefContext.toAst(): Statement =
+        Label(children[0].text, toPosition())
+
+
+private fun prog8Parser.SubroutineContext.toAst() : Subroutine {
+    return Subroutine(identifier().text,
+            sub_params()?.toAst() ?: emptyList(),
+            sub_return_part()?.toAst() ?: emptyList(),
+            emptyList(),
+            emptyList(),
+            emptySet(),
+            null,
+            false,
+            statement_block()?.toAst() ?: mutableListOf(),
+            toPosition())
+}
+
+private fun prog8Parser.Sub_return_partContext.toAst(): List<DataType> {
+    val returns = sub_returns() ?: return emptyList()
+    return returns.datatype().map { it.toAst() }
+}
+
+
+private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
+        vardecl().map {
+            val datatype = it.datatype()?.toAst() ?: DataType.STRUCT
+            SubroutineParameter(it.varname.text, datatype, it.toPosition())
+        }
+
+
+private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
+    val register = register()?.toAst()
+    val identifier = scoped_identifier()
+    return when {
+        register!=null -> AssignTarget(register, null, null, null, toPosition())
+        identifier!=null -> AssignTarget(null, identifier.toAst(), null, null, toPosition())
+        arrayindexed()!=null -> AssignTarget(null, null, arrayindexed().toAst(), null, toPosition())
+        directmemory()!=null -> AssignTarget(null, null, null, DirectMemoryWrite(directmemory().expression().toAst(), toPosition()), toPosition())
+        else -> AssignTarget(null, scoped_identifier()?.toAst(), null, null, toPosition())
+    }
+}
+
+private fun prog8Parser.RegisterContext.toAst() = Register.valueOf(text.toUpperCase())
+
+private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.toUpperCase())
+
+private fun prog8Parser.RegisterorpairContext.toAst() = RegisterOrPair.valueOf(text.toUpperCase())
+
+
+private fun prog8Parser.ArrayindexContext.toAst() : ArrayIndex =
+        ArrayIndex(expression().toAst(), toPosition())
+
+
+private fun prog8Parser.DirectiveContext.toAst() : Directive =
+        Directive(directivename.text, directivearg().map { it.toAst() }, toPosition())
+
+
+private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg =
+        DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
+
+
+private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
+    fun makeLiteral(text: String, radix: Int, forceWord: Boolean): NumericLiteral {
+        val integer: Int
+        var datatype = DataType.UBYTE
+        when (radix) {
+            10 -> {
+                integer = try {
+                    text.toInt()
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid decimal literal ${x.message}")
+                }
+                datatype = when(integer) {
+                    in 0..255 -> DataType.UBYTE
+                    in -128..127 -> DataType.BYTE
+                    in 0..65535 -> DataType.UWORD
+                    in -32768..32767 -> DataType.WORD
+                    else -> DataType.FLOAT
+                }
+            }
+            2 -> {
+                if(text.length>8)
+                    datatype = DataType.UWORD
+                try {
+                    integer = text.toInt(2)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid binary literal ${x.message}")
+                }
+            }
+            16 -> {
+                if(text.length>2)
+                    datatype = DataType.UWORD
+                try {
+                    integer = text.toInt(16)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid hexadecimal literal ${x.message}")
+                }
+            }
+            else -> throw FatalAstException("invalid radix")
+        }
+        return NumericLiteral(integer, if (forceWord) DataType.UWORD else datatype)
+    }
+    val terminal: TerminalNode = children[0] as TerminalNode
+    val integerPart = this.intpart.text
+    return when (terminal.symbol.type) {
+        prog8Parser.DEC_INTEGER -> makeLiteral(integerPart, 10, wordsuffix()!=null)
+        prog8Parser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16, wordsuffix()!=null)
+        prog8Parser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2, wordsuffix()!=null)
+        else -> throw FatalAstException(terminal.text)
+    }
+}
+
+
+private fun prog8Parser.ExpressionContext.toAst() : Expression {
+
+    val litval = literalvalue()
+    if(litval!=null) {
+        val booleanlit = litval.booleanliteral()?.toAst()
+        return if(booleanlit!=null) {
+            NumericLiteralValue.fromBoolean(booleanlit, litval.toPosition())
+        }
+        else {
+            val intLit = litval.integerliteral()?.toAst()
+            when {
+                intLit!=null -> when(intLit.datatype) {
+                    DataType.UBYTE -> NumericLiteralValue(DataType.UBYTE, intLit.number.toShort(), litval.toPosition())
+                    DataType.BYTE -> NumericLiteralValue(DataType.BYTE, intLit.number.toShort(), litval.toPosition())
+                    DataType.UWORD -> NumericLiteralValue(DataType.UWORD, intLit.number.toInt(), litval.toPosition())
+                    DataType.WORD -> NumericLiteralValue(DataType.WORD, intLit.number.toInt(), litval.toPosition())
+                    DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, intLit.number.toDouble(), litval.toPosition())
+                    else -> throw FatalAstException("invalid datatype for numeric literal")
+                }
+                litval.floatliteral()!=null -> NumericLiteralValue(DataType.FLOAT, litval.floatliteral().toAst(), litval.toPosition())
+                litval.stringliteral()!=null -> ReferenceLiteralValue(DataType.STR, unescape(litval.stringliteral().text, litval.toPosition()), position = litval.toPosition())
+                litval.charliteral()!=null -> {
+                    try {
+                        NumericLiteralValue(DataType.UBYTE, Petscii.encodePetscii(unescape(litval.charliteral().text, litval.toPosition()), true)[0], litval.toPosition())
+                    } catch (ce: CharConversionException) {
+                        throw SyntaxError(ce.message ?: ce.toString(), litval.toPosition())
+                    }
+                }
+                litval.arrayliteral()!=null -> {
+                    val array = litval.arrayliteral()?.toAst()
+                    // the actual type of the arraysize can not yet be determined here (missing namespace & heap)
+                    // the ConstantFold takes care of that and converts the type if needed.
+                    ReferenceLiteralValue(DataType.ARRAY_UB, array = array, position = litval.toPosition())
+                }
+                litval.structliteral()!=null -> {
+                    val values = litval.structliteral().expression().map { it.toAst() }
+                    StructLiteralValue(values, litval.toPosition())
+                }
+                else -> throw FatalAstException("invalid parsed literal")
+            }
+        }
+    }
+
+    if(register()!=null)
+        return RegisterExpr(register().toAst(), register().toPosition())
+
+    if(scoped_identifier()!=null)
+        return scoped_identifier().toAst()
+
+    if(bop!=null)
+        return BinaryExpression(left.toAst(), bop.text, right.toAst(), toPosition())
+
+    if(prefix!=null)
+        return PrefixExpression(prefix.text, expression(0).toAst(), toPosition())
+
+    val funcall = functioncall()?.toAst()
+    if(funcall!=null) return funcall
+
+    if (rangefrom!=null && rangeto!=null) {
+        val step = rangestep?.toAst() ?: NumericLiteralValue(DataType.UBYTE, 1, toPosition())
+        return RangeExpr(rangefrom.toAst(), rangeto.toAst(), step, toPosition())
+    }
+
+    if(childCount==3 && children[0].text=="(" && children[2].text==")")
+        return expression(0).toAst()        // expression within ( )
+
+    if(arrayindexed()!=null)
+        return arrayindexed().toAst()
+
+    if(typecast()!=null)
+        return TypecastExpression(expression(0).toAst(), typecast().datatype().toAst(), false, toPosition())
+
+    if(directmemory()!=null)
+        return DirectMemoryRead(directmemory().expression().toAst(), toPosition())
+
+    if(addressof()!=null)
+        return AddressOf(addressof().scoped_identifier().toAst(), toPosition())
+
+    throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.ArrayindexedContext.toAst(): ArrayIndexedExpression {
+    return ArrayIndexedExpression(scoped_identifier().toAst(),
+            arrayindex().toAst(),
+            toPosition())
+}
+
+
+private fun prog8Parser.Expression_listContext.toAst() = expression().map{ it.toAst() }
+
+
+private fun prog8Parser.IdentifierContext.toAst() : IdentifierReference =
+        IdentifierReference(listOf(text), toPosition())
+
+
+private fun prog8Parser.Scoped_identifierContext.toAst() : IdentifierReference =
+        IdentifierReference(NAME().map { it.text }, toPosition())
+
+
+private fun prog8Parser.FloatliteralContext.toAst() = text.toDouble()
+
+
+private fun prog8Parser.BooleanliteralContext.toAst() = when(text) {
+    "true" -> true
+    "false" -> false
+    else -> throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.ArrayliteralContext.toAst() : Array<Expression> =
+        expression().map { it.toAst() }.toTypedArray()
+
+private fun prog8Parser.If_stmtContext.toAst(): IfStatement {
+    val condition = expression().toAst()
+    val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val elseStatements = else_part()?.toAst() ?: mutableListOf()
+    val trueScope = AnonymousScope(trueStatements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    val elseScope = AnonymousScope(elseStatements, else_part()?.toPosition() ?: toPosition())
+    return IfStatement(condition, trueScope, elseScope, toPosition())
+}
+
+private fun prog8Parser.Else_partContext.toAst(): MutableList<Statement> {
+    return statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+}
+
+
+private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
+    val branchcondition = branchcondition().toAst()
+    val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val elseStatements = else_part()?.toAst() ?: mutableListOf()
+    val trueScope = AnonymousScope(trueStatements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    val elseScope = AnonymousScope(elseStatements, else_part()?.toPosition() ?: toPosition())
+    return BranchStatement(branchcondition, trueScope, elseScope, toPosition())
+}
+
+private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf(text.substringAfter('_').toUpperCase())
+
+
+private fun prog8Parser.ForloopContext.toAst(): ForLoop {
+    val loopregister = register()?.toAst()
+    val datatype = datatype()?.toAst()
+    val zeropage = if(ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE
+    val loopvar = identifier()?.toAst()
+    val iterable = expression()!!.toAst()
+    val scope =
+            if(statement()!=null)
+                AnonymousScope(mutableListOf(statement().toAst()), statement().toPosition())
+            else
+                AnonymousScope(statement_block().toAst(), statement_block().toPosition())
+    return ForLoop(loopregister, datatype, zeropage, loopvar, iterable, scope, toPosition())
+}
+
+
+private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
+
+private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
+
+
+private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
+    val condition = expression().toAst()
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return WhileLoop(condition, scope, toPosition())
+}
+
+
+private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
+    val untilCondition = expression().toAst()
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return RepeatLoop(scope, untilCondition, toPosition())
+}
+
+private fun prog8Parser.WhenstmtContext.toAst(): WhenStatement {
+    val condition = expression().toAst()
+    val choices = this.when_choice()?.map { it.toAst() }?.toMutableList() ?: mutableListOf()
+    return WhenStatement(condition, choices, toPosition())
+}
+
+private fun prog8Parser.When_choiceContext.toAst(): WhenChoice {
+    val values = expression_list()?.toAst()
+    val stmt = statement()?.toAst()
+    val stmt_block = statement_block()?.toAst()?.toMutableList() ?: mutableListOf()
+    if(stmt!=null)
+        stmt_block.add(stmt)
+    val scope = AnonymousScope(stmt_block, toPosition())
+    return WhenChoice(values, scope, toPosition())
+}
+
+private fun prog8Parser.VardeclContext.toAst(): VarDecl {
+    return VarDecl(
+            VarDeclType.VAR,
+            datatype()?.toAst() ?: DataType.STRUCT,
+            if(ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+            arrayindex()?.toAst(),
+            varname.text,
+            null,
+            null,
+            ARRAYSIG() != null || arrayindex() != null,
+            false,
+            toPosition()
+    )
+}
+
+internal fun escape(str: String) = str.replace("\t", "\\t").replace("\n", "\\n").replace("\r", "\\r")
+
+internal fun unescape(str: String, position: Position): String {
+    val result = mutableListOf<Char>()
+    val iter = str.iterator()
+    while(iter.hasNext()) {
+        val c = iter.nextChar()
+        if(c=='\\') {
+            val ec = iter.nextChar()
+            result.add(when(ec) {
+                '\\' -> '\\'
+                'n' -> '\n'
+                'r' -> '\r'
+                '"' -> '"'
+                'u' -> {
+                    "${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}".toInt(16).toChar()
+                }
+                else -> throw SyntaxError("invalid escape char in string: \\$ec", position)
+            })
+        } else {
+            result.add(c)
+        }
+    }
+    return result.joinToString("")
+}
+

compiler/src/prog8/ast/base/Base.kt

@@ -0,0 +1,153 @@
+package prog8.ast.base
+
+import prog8.ast.Node
+import prog8.compiler.target.c64.MachineDefinition
+
+/**************************** AST Data classes ****************************/
+
+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
+    STR_S,              // 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
+    STRUCT;             // pass by reference
+
+    /**
+     * is the type assignable to the given other type?
+     */
+    infix fun isAssignableTo(targetType: DataType) =
+            // what types are assignable to others without loss of precision?
+            when(this) {
+                UBYTE -> targetType in setOf(UBYTE, WORD, UWORD, FLOAT)
+                BYTE -> targetType in setOf(BYTE, WORD, FLOAT)
+                UWORD -> targetType in setOf(UWORD, FLOAT)
+                WORD -> targetType in setOf(WORD, FLOAT)
+                FLOAT -> targetType == FLOAT
+                STR -> targetType == STR || targetType==STR_S
+                STR_S -> targetType == STR || targetType==STR_S
+                in ArrayDatatypes -> targetType == this
+                else -> false
+            }
+
+
+    infix fun isAssignableTo(targetTypes: Set<DataType>) = targetTypes.any { this isAssignableTo it }
+
+    infix fun largerThan(other: DataType) =
+            when(this) {
+                in ByteDatatypes -> false
+                in WordDatatypes -> other in ByteDatatypes
+                else -> true
+            }
+
+    infix fun equalsSize(other: DataType) =
+            when(this) {
+                in ByteDatatypes -> other in ByteDatatypes
+                in WordDatatypes -> other in WordDatatypes
+                else -> false
+            }
+
+    fun memorySize(): Int {
+        return when(this) {
+            in ByteDatatypes -> 1
+            in WordDatatypes -> 2
+            FLOAT -> MachineDefinition.Mflpt5.MemorySize
+            in PassByReferenceDatatypes -> 2
+            else -> -9999999
+        }
+    }
+}
+
+enum class Register {
+    A,
+    X,
+    Y
+}
+
+enum class RegisterOrPair {
+    A,
+    X,
+    Y,
+    AX,
+    AY,
+    XY
+}       // only used in parameter and return value specs in asm subroutines
+
+enum class Statusflag {
+    Pc,
+    Pz,
+    Pv,
+    Pn
+}
+
+enum class BranchCondition {
+    CS,
+    CC,
+    EQ,
+    Z,
+    NE,
+    NZ,
+    VS,
+    VC,
+    MI,
+    NEG,
+    PL,
+    POS
+}
+
+enum class VarDeclType {
+    VAR,
+    CONST,
+    MEMORY
+}
+
+val ByteDatatypes = setOf(DataType.UBYTE, DataType.BYTE)
+val WordDatatypes = setOf(DataType.UWORD, DataType.WORD)
+val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
+val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+val StringDatatypes = setOf(DataType.STR, DataType.STR_S)
+val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val IterableDatatypes = setOf(
+        DataType.STR, DataType.STR_S,
+        DataType.ARRAY_UB, DataType.ARRAY_B,
+        DataType.ARRAY_UW, DataType.ARRAY_W,
+        DataType.ARRAY_F)
+val PassByValueDatatypes = NumericDatatypes
+val PassByReferenceDatatypes = IterableDatatypes.plus(DataType.STRUCT)
+val ArrayElementTypes = mapOf(
+        DataType.STR to DataType.UBYTE,
+        DataType.STR_S 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)
+
+// find the parent node of a specific type or interface
+// (useful to figure out in what namespace/block something is defined, etc)
+inline fun <reified T> findParentNode(node: Node): T? {
+    var candidate = node.parent
+    while(candidate !is T && candidate !is ParentSentinel)
+        candidate = candidate.parent
+    return if(candidate is ParentSentinel)
+        null
+    else
+        candidate as T
+}
+
+object ParentSentinel : Node {
+    override val position = Position("<<sentinel>>", 0, 0, 0)
+    override var parent: Node = this
+    override fun linkParents(parent: Node) {}
+}
+
+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}]"
+}

compiler/src/prog8/ast/base/ErrorReporting.kt

@@ -0,0 +1,37 @@
+package prog8.ast.base
+
+import prog8.parser.ParsingFailedError
+
+
+fun printErrors(errors: List<Any>, moduleName: String) {
+    val reportedMessages = mutableSetOf<String>()
+    print("\u001b[91m")  // bright red
+    errors.forEach {
+        val msg = it.toString()
+        if(msg !in reportedMessages) {
+            System.err.println(msg)
+            reportedMessages.add(msg)
+        }
+    }
+    print("\u001b[0m")  // reset color
+    if(reportedMessages.isNotEmpty())
+        throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
+}
+
+
+fun printWarning(msg: String, position: Position, detailInfo: String?=null) {
+    print("\u001b[93m")  // bright yellow
+    print("$position Warning: $msg")
+    if(detailInfo==null)
+        print("\n")
+    else
+        println(": $detailInfo\n")
+    print("\u001b[0m")  // normal
+}
+
+
+fun printWarning(msg: String) {
+    print("\u001b[93m")  // bright yellow
+    print("Warning: $msg")
+    print("\u001b[0m\n")  // normal
+}

compiler/src/prog8/ast/base/Errors.kt

@@ -0,0 +1,22 @@
+package prog8.ast.base
+
+import prog8.ast.expressions.IdentifierReference
+
+class FatalAstException (override var message: String) : Exception(message)
+
+open class AstException (override var message: String) : Exception(message)
+
+class SyntaxError(override var message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Syntax error: $message"
+}
+
+class NameError(override var message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Name error: $message"
+}
+
+open class ExpressionError(message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Error: $message"
+}
+
+class UndefinedSymbolError(symbol: IdentifierReference)
+    : ExpressionError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)

compiler/src/prog8/ast/base/Extensions.kt

@@ -0,0 +1,65 @@
+package prog8.ast.base
+
+import prog8.ast.Module
+import prog8.ast.Program
+import prog8.ast.processing.*
+import prog8.compiler.CompilationOptions
+import prog8.compiler.target.c64.codegen2.AnonymousScopeVarsCleanup
+import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
+
+
+// the name of the subroutine that should be called for every block to initialize its variables
+internal const val initvarsSubName="prog8_init_vars"
+
+
+internal fun Program.removeNopsFlattenAnonScopes() {
+    val flattener = FlattenAnonymousScopesAndRemoveNops()
+    flattener.visit(this)
+}
+
+
+internal fun Program.checkValid(compilerOptions: CompilationOptions) {
+    val checker = AstChecker(this, compilerOptions)
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+
+internal fun Program.anonscopeVarsCleanup() {
+    val mover = AnonymousScopeVarsCleanup(this)
+    mover.visit(this)
+    printErrors(mover.result(), name)
+}
+
+
+internal fun Program.reorderStatements() {
+    val initvalueCreator = VarInitValueAndAddressOfCreator(this)
+    initvalueCreator.visit(this)
+
+    val checker = StatementReorderer(this)
+    checker.visit(this)
+}
+
+internal fun Module.checkImportedValid() {
+    val checker = ImportedModuleDirectiveRemover()
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+internal fun Program.checkRecursion() {
+    val checker = AstRecursionChecker(namespace)
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+
+internal fun Program.checkIdentifiers() {
+    val checker = AstIdentifiersChecker(this)
+    checker.visit(this)
+
+    if(modules.map {it.name}.toSet().size != modules.size) {
+        throw FatalAstException("modules should all be unique")
+    }
+
+    printErrors(checker.result(), name)
+}

compiler/src/prog8/ast/expressions/AstExpressions.kt

@@ -0,0 +1,780 @@
+package prog8.ast.expressions
+
+import prog8.ast.IFunctionCall
+import prog8.ast.INameScope
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.antlr.escape
+import prog8.ast.base.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.ArrayIndex
+import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
+import prog8.ast.statements.Subroutine
+import prog8.ast.statements.VarDecl
+import prog8.compiler.HeapValues
+import prog8.compiler.IntegerOrAddressOf
+import prog8.compiler.target.c64.Petscii
+import prog8.functions.BuiltinFunctions
+import prog8.functions.NotConstArgumentException
+import prog8.functions.builtinFunctionReturnType
+import kotlin.math.abs
+
+
+val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
+
+
+sealed class Expression: Node {
+    abstract fun constValue(program: Program): NumericLiteralValue?
+    abstract fun accept(visitor: IAstModifyingVisitor): Expression
+    abstract fun accept(visitor: IAstVisitor)
+    abstract fun referencesIdentifiers(vararg name: String): Boolean     // todo: remove this here and move it into CallGraph instead
+    abstract fun inferType(program: Program): DataType?
+
+    infix fun isSameAs(other: Expression): Boolean {
+        if(this===other)
+            return true
+        when(this) {
+            is RegisterExpr ->
+                return (other is RegisterExpr && other.register==register)
+            is IdentifierReference ->
+                return (other is IdentifierReference && other.nameInSource==nameInSource)
+            is PrefixExpression ->
+                return (other is PrefixExpression && other.operator==operator && other.expression isSameAs expression)
+            is BinaryExpression ->
+                return (other is BinaryExpression && other.operator==operator
+                        && other.left isSameAs left
+                        && other.right isSameAs right)
+            is ArrayIndexedExpression -> {
+                return (other is ArrayIndexedExpression && other.identifier.nameInSource == identifier.nameInSource
+                        && other.arrayspec.index isSameAs arrayspec.index)
+            }
+            else -> return other==this
+        }
+    }
+}
+
+
+class PrefixExpression(val operator: String, var expression: Expression, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        expression.linkParents(this)
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? = expression.inferType(program)
+
+    override fun toString(): String {
+        return "Prefix($operator $expression)"
+    }
+}
+
+class BinaryExpression(var left: Expression, var operator: String, var right: Expression, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        left.linkParents(this)
+        right.linkParents(this)
+    }
+
+    override fun toString(): String {
+        return "[$left $operator $right]"
+    }
+
+    // binary expression should actually have been optimized away into a single value, before const value was requested...
+    override fun constValue(program: Program): NumericLiteralValue? = null
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = left.referencesIdentifiers(*name) || right.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? {
+        val leftDt = left.inferType(program)
+        val rightDt = right.inferType(program)
+        return when (operator) {
+            "+", "-", "*", "**", "%", "/" -> if (leftDt == null || rightDt == null) null else {
+                try {
+                    commonDatatype(leftDt, rightDt, null, null).first
+                } catch (x: FatalAstException) {
+                    null
+                }
+            }
+            "&" -> leftDt
+            "|" -> leftDt
+            "^" -> leftDt
+            "and", "or", "xor",
+            "<", ">",
+            "<=", ">=",
+            "==", "!=" -> DataType.UBYTE
+            "<<", ">>" -> leftDt
+            else -> throw FatalAstException("resulting datatype check for invalid operator $operator")
+        }
+    }
+
+    companion object {
+        fun commonDatatype(leftDt: DataType, rightDt: DataType,
+                           left: Expression?, right: Expression?): Pair<DataType, Expression?> {
+            // byte + byte -> byte
+            // byte + word -> word
+            // word + byte -> word
+            // word + word -> word
+            // a combination with a float will be float (but give a warning about this!)
+
+            return when (leftDt) {
+                DataType.UBYTE -> {
+                    when (rightDt) {
+                        DataType.UBYTE -> Pair(DataType.UBYTE, null)
+                        DataType.BYTE -> Pair(DataType.BYTE, left)
+                        DataType.UWORD -> Pair(DataType.UWORD, left)
+                        DataType.WORD -> Pair(DataType.WORD, left)
+                        DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                        else -> Pair(leftDt, null)      // non-numeric datatype
+                    }
+                }
+                DataType.BYTE -> {
+                    when (rightDt) {
+                        DataType.UBYTE -> Pair(DataType.BYTE, right)
+                        DataType.BYTE -> Pair(DataType.BYTE, null)
+                        DataType.UWORD -> Pair(DataType.WORD, left)
+                        DataType.WORD -> Pair(DataType.WORD, left)
+                        DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                        else -> Pair(leftDt, null)      // non-numeric datatype
+                    }
+                }
+                DataType.UWORD -> {
+                    when (rightDt) {
+                        DataType.UBYTE -> Pair(DataType.UWORD, right)
+                        DataType.BYTE -> Pair(DataType.WORD, right)
+                        DataType.UWORD -> Pair(DataType.UWORD, null)
+                        DataType.WORD -> Pair(DataType.WORD, left)
+                        DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                        else -> Pair(leftDt, null)      // non-numeric datatype
+                    }
+                }
+                DataType.WORD -> {
+                    when (rightDt) {
+                        DataType.UBYTE -> Pair(DataType.WORD, right)
+                        DataType.BYTE -> Pair(DataType.WORD, right)
+                        DataType.UWORD -> Pair(DataType.WORD, right)
+                        DataType.WORD -> Pair(DataType.WORD, null)
+                        DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                        else -> Pair(leftDt, null)      // non-numeric datatype
+                    }
+                }
+                DataType.FLOAT -> {
+                    Pair(DataType.FLOAT, right)
+                }
+                else -> Pair(leftDt, null)      // non-numeric datatype
+            }
+        }
+    }
+}
+
+class ArrayIndexedExpression(var identifier: IdentifierReference,
+                             val arrayspec: ArrayIndex,
+                             override val position: Position) : Expression() {
+    override lateinit var parent: Node
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier.linkParents(this)
+        arrayspec.linkParents(this)
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = identifier.referencesIdentifiers(*name)
+
+    override fun inferType(program: Program): DataType? {
+        val target = identifier.targetStatement(program.namespace)
+        if (target is VarDecl) {
+            return when (target.datatype) {
+                in NumericDatatypes -> null
+                in StringDatatypes -> DataType.UBYTE
+                in ArrayDatatypes -> ArrayElementTypes[target.datatype]
+                else -> throw FatalAstException("invalid dt")
+            }
+        }
+        return null
+    }
+
+    override fun toString(): String {
+        return "ArrayIndexed(ident=$identifier, arraysize=$arrayspec; pos=$position)"
+    }
+}
+
+class TypecastExpression(var expression: Expression, var type: DataType, val implicit: Boolean, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        expression.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? = type
+    override fun constValue(program: Program): NumericLiteralValue? {
+        val cv = expression.constValue(program) ?: return null
+        return cv.cast(type)
+        // val value = RuntimeValue(cv.type, cv.asNumericValue!!).cast(type)
+        // return LiteralValue.fromNumber(value.numericValue(), value.type, position).cast(type)
+    }
+
+    override fun toString(): String {
+        return "Typecast($expression as $type)"
+    }
+}
+
+data class AddressOf(var identifier: IdentifierReference, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier.parent=this
+    }
+
+    var scopedname: String? = null     // will be set in a later state by the compiler  // TODO get rid of this??
+    override fun constValue(program: Program): NumericLiteralValue? = null
+    override fun referencesIdentifiers(vararg name: String) = false
+    override fun inferType(program: Program) = DataType.UWORD
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class DirectMemoryRead(var addressExpression: Expression, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.addressExpression.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = false
+    override fun inferType(program: Program): DataType? = DataType.UBYTE
+    override fun constValue(program: Program): NumericLiteralValue? = null
+
+    override fun toString(): String {
+        return "DirectMemoryRead($addressExpression)"
+    }
+}
+
+class NumericLiteralValue(val type: DataType,    // only numerical types allowed
+                          val number: Number,    // can be byte, word or float depending on the type
+                          override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    companion object {
+        fun fromBoolean(bool: Boolean, position: Position) =
+                NumericLiteralValue(DataType.UBYTE, if (bool) 1 else 0, position)
+
+        fun optimalNumeric(value: Number, position: Position): NumericLiteralValue {
+            return if(value is Double) {
+                NumericLiteralValue(DataType.FLOAT, value, position)
+            } else {
+                when (val intval = value.toInt()) {
+                    in 0..255 -> NumericLiteralValue(DataType.UBYTE, intval, position)
+                    in -128..127 -> NumericLiteralValue(DataType.BYTE, intval, position)
+                    in 0..65535 -> NumericLiteralValue(DataType.UWORD, intval, position)
+                    in -32768..32767 -> NumericLiteralValue(DataType.WORD, intval, position)
+                    else -> NumericLiteralValue(DataType.FLOAT, intval.toDouble(), position)
+                }
+            }
+        }
+
+        fun optimalInteger(value: Int, position: Position): NumericLiteralValue {
+            return when (value) {
+                in 0..255 -> NumericLiteralValue(DataType.UBYTE, value, position)
+                in -128..127 -> NumericLiteralValue(DataType.BYTE, value, position)
+                in 0..65535 -> NumericLiteralValue(DataType.UWORD, value, position)
+                in -32768..32767 -> NumericLiteralValue(DataType.WORD, value, position)
+                else -> throw FatalAstException("integer overflow: $value")
+            }
+        }
+    }
+
+    val asBooleanValue: Boolean = number!=0
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun referencesIdentifiers(vararg name: String) = false
+    override fun constValue(program: Program) = this
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String = "NumericLiteral(${type.name}:$number)"
+
+    override fun inferType(program: Program) = type
+
+    override fun hashCode(): Int  = type.hashCode() * 31 xor number.hashCode()
+
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is NumericLiteralValue)
+            return false
+        return number.toDouble()==other.number.toDouble()
+    }
+
+    operator fun compareTo(other: NumericLiteralValue): Int = number.toDouble().compareTo(other.number.toDouble())
+
+    fun cast(targettype: DataType): NumericLiteralValue? {
+        if(type==targettype)
+            return this
+        val numval = number.toDouble()
+        when(type) {
+            DataType.UBYTE -> {
+                if(targettype== DataType.BYTE && numval <= 127)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.WORD || targettype== DataType.UWORD)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if(targettype== DataType.FLOAT)
+                    return NumericLiteralValue(targettype, number.toDouble(), position)
+            }
+            DataType.BYTE -> {
+                if(targettype== DataType.UBYTE && numval >= 0)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.UWORD && numval >= 0)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if(targettype== DataType.WORD)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if(targettype== DataType.FLOAT)
+                    return NumericLiteralValue(targettype, number.toDouble(), position)
+            }
+            DataType.UWORD -> {
+                if(targettype== DataType.BYTE && numval <= 127)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.UBYTE && numval <= 255)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.WORD && numval <= 32767)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if(targettype== DataType.FLOAT)
+                    return NumericLiteralValue(targettype, number.toDouble(), position)
+            }
+            DataType.WORD -> {
+                if(targettype== DataType.BYTE && numval >= -128 && numval <=127)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.UBYTE && numval >= 0 && numval <= 255)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if(targettype== DataType.UWORD && numval >=0)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if(targettype== DataType.FLOAT)
+                    return NumericLiteralValue(targettype, number.toDouble(), position)
+            }
+            DataType.FLOAT -> {
+                if (targettype == DataType.BYTE && numval >= -128 && numval <=127)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if (targettype == DataType.UBYTE && numval >=0 && numval <= 255)
+                    return NumericLiteralValue(targettype, number.toShort(), position)
+                if (targettype == DataType.WORD && numval >= -32768 && numval <= 32767)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+                if (targettype == DataType.UWORD && numval >=0 && numval <= 65535)
+                    return NumericLiteralValue(targettype, number.toInt(), position)
+            }
+            else -> {}
+        }
+        return null    // invalid type conversion from $this to $targettype
+    }
+}
+
+class StructLiteralValue(var values: List<Expression>,
+                         override val position: Position): Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+        values.forEach { it.linkParents(this) }
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue?  = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = values.any { it.referencesIdentifiers(*name) }
+    override fun inferType(program: Program) = DataType.STRUCT
+
+    override fun toString(): String {
+        return "struct{ ${values.joinToString(", ")} }"
+    }
+}
+
+class ReferenceLiteralValue(val type: DataType,     // only reference types allowed here
+                            val str: String? = null,
+                            val array: Array<Expression>? = null,
+                            // actually, at the moment, we don't have struct literals in the language
+                            initHeapId: Int? =null,
+                            override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun referencesIdentifiers(vararg name: String) = array?.any { it.referencesIdentifiers(*name) } ?: false
+
+    val isString = type in StringDatatypes
+    val isArray = type in ArrayDatatypes
+    var heapId = initHeapId
+        private set
+
+    init {
+        when(type){
+            in StringDatatypes ->
+                if(str==null) throw FatalAstException("literal value missing strvalue/heapId")
+            in ArrayDatatypes ->
+                if(array==null) throw FatalAstException("literal value missing arrayvalue/heapId")
+            else -> throw FatalAstException("invalid type $type")
+        }
+        if(array==null && str==null)
+            throw FatalAstException("literal ref value without actual value")
+    }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        array?.forEach {it.linkParents(this)}
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? {
+        // note that we can't handle arrays that only contain constant numbers here anymore
+        // so they're not treated as constants anymore
+        return null
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        val valueStr = when(type) {
+            in StringDatatypes -> "'${escape(str!!)}'"
+            in ArrayDatatypes -> "$array"
+            else -> throw FatalAstException("weird ref type")
+        }
+        return "RefValueLit($type, $valueStr)"
+    }
+
+    override fun inferType(program: Program) = type
+
+    override fun hashCode(): Int {
+        val sh = str?.hashCode() ?: 0x00014567
+        val ah = array?.hashCode() ?: 0x11119876
+        return sh * 31 xor ah xor type.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is ReferenceLiteralValue)
+            return false
+        if(isArray && other.isArray)
+            return array!!.contentEquals(other.array!!) && heapId==other.heapId
+        if(isString && other.isString)
+            return str==other.str && heapId==other.heapId
+
+        if(type!=other.type)
+            return false
+
+        return compareTo(other) == 0
+    }
+
+    operator fun compareTo(other: ReferenceLiteralValue): Int {
+        throw ExpressionError("cannot order compare type $type with ${other.type}", other.position)
+    }
+
+    fun cast(targettype: DataType): ReferenceLiteralValue? {
+        if(type==targettype)
+            return this
+        when(type) {
+            in StringDatatypes -> {
+                if(targettype in StringDatatypes)
+                    return ReferenceLiteralValue(targettype, str, position = position)
+            }
+            in ArrayDatatypes -> {
+                if(targettype in ArrayDatatypes) {
+                    val elementType = ArrayElementTypes.getValue(targettype)
+                    val castArray = array!!.map{
+                        val num = it as? NumericLiteralValue
+                        if(num==null) {
+                            // an array of UWORDs could possibly also contain AddressOfs
+                            if (elementType != DataType.UWORD || it !is AddressOf)
+                                throw FatalAstException("weird array element $it")
+                            it
+                        } else {
+                            num.cast(elementType)!!
+                        }
+                    }.toTypedArray()
+                    return ReferenceLiteralValue(targettype, null, array=castArray, position = position)
+                }
+            }
+            else -> {}
+        }
+        return null    // invalid type conversion from $this to $targettype
+    }
+
+    fun addToHeap(heap: HeapValues) {
+        if (heapId != null) return
+        if (str != null) {
+            heapId = heap.addString(type, str)
+        }
+        else if (array!=null) {
+            if(array.any {it is AddressOf }) {
+                val intArrayWithAddressOfs = array.map {
+                    when (it) {
+                        is AddressOf -> IntegerOrAddressOf(null, it)
+                        is NumericLiteralValue -> IntegerOrAddressOf(it.number.toInt(), null)
+                        else -> throw FatalAstException("invalid datatype in array")
+                    }
+                }
+                heapId = heap.addIntegerArray(type, intArrayWithAddressOfs.toTypedArray())
+            } else {
+                val valuesInArray = array.map { (it as? NumericLiteralValue)?.number }
+                if(null !in valuesInArray) {
+                    heapId = if (type == DataType.ARRAY_F) {
+                        val doubleArray = valuesInArray.map { it!!.toDouble() }.toDoubleArray()
+                        heap.addDoublesArray(doubleArray)
+                    } else {
+                        val integerArray = valuesInArray.map { it!!.toInt() }
+                        heap.addIntegerArray(type, integerArray.map { IntegerOrAddressOf(it, null) }.toTypedArray())
+                    }
+                }
+            }
+        }
+    }
+}
+
+class RangeExpr(var from: Expression,
+                var to: Expression,
+                var step: Expression,
+                override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        from.linkParents(this)
+        to.linkParents(this)
+        step.linkParents(this)
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean  = from.referencesIdentifiers(*name) || to.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? {
+        val fromDt=from.inferType(program)
+        val toDt=to.inferType(program)
+        return when {
+            fromDt==null || toDt==null -> null
+            fromDt== DataType.UBYTE && toDt== DataType.UBYTE -> DataType.ARRAY_UB
+            fromDt== DataType.UWORD && toDt== DataType.UWORD -> DataType.ARRAY_UW
+            fromDt== DataType.STR && toDt== DataType.STR -> DataType.STR
+            fromDt== DataType.STR_S && toDt== DataType.STR_S -> DataType.STR_S
+            fromDt== DataType.WORD || toDt== DataType.WORD -> DataType.ARRAY_W
+            fromDt== DataType.BYTE || toDt== DataType.BYTE -> DataType.ARRAY_B
+            else -> DataType.ARRAY_UB
+        }
+    }
+    override fun toString(): String {
+        return "RangeExpr(from $from, to $to, step $step, pos=$position)"
+    }
+
+    fun size(): Int? {
+        val fromLv = (from as? NumericLiteralValue)
+        val toLv = (to as? NumericLiteralValue)
+        if(fromLv==null || toLv==null)
+            return null
+        return toConstantIntegerRange()?.count()
+    }
+
+    fun toConstantIntegerRange(): IntProgression? {
+        val fromVal: Int
+        val toVal: Int
+        val fromRlv = from as? ReferenceLiteralValue
+        val toRlv = to as? ReferenceLiteralValue
+        if(fromRlv!=null && fromRlv.isString && toRlv!=null && toRlv.isString) {
+            // string range -> int range over petscii values
+            fromVal = Petscii.encodePetscii(fromRlv.str!!, true)[0].toInt()
+            toVal = Petscii.encodePetscii(toRlv.str!!, true)[0].toInt()
+        } else {
+            val fromLv = from as? NumericLiteralValue
+            val toLv = to as? NumericLiteralValue
+            if(fromLv==null || toLv==null)
+                return null         // non-constant range
+            // integer range
+            fromVal = fromLv.number.toInt()
+            toVal = toLv.number.toInt()
+        }
+        val stepVal = (step as? NumericLiteralValue)?.number?.toInt() ?: 1
+        return when {
+            fromVal <= toVal -> when {
+                stepVal <= 0 -> IntRange.EMPTY
+                stepVal == 1 -> fromVal..toVal
+                else -> fromVal..toVal step stepVal
+            }
+            else -> when {
+                stepVal >= 0 -> IntRange.EMPTY
+                stepVal == -1 -> fromVal downTo toVal
+                else -> fromVal downTo toVal step abs(stepVal)
+            }
+        }
+    }
+}
+
+class RegisterExpr(val register: Register, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = register.name in name
+    override fun toString(): String {
+        return "RegisterExpr(register=$register, pos=$position)"
+    }
+
+    override fun inferType(program: Program) = DataType.UBYTE
+}
+
+data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    fun targetStatement(namespace: INameScope) =
+        if(nameInSource.size==1 && nameInSource[0] in BuiltinFunctions)
+            BuiltinFunctionStatementPlaceholder(nameInSource[0], position)
+        else
+            namespace.lookup(nameInSource, this)
+
+    fun targetVarDecl(namespace: INameScope): VarDecl? = targetStatement(namespace) as? VarDecl
+    fun targetSubroutine(namespace: INameScope): Subroutine? = targetStatement(namespace) as? Subroutine
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun constValue(program: Program): NumericLiteralValue? {
+        val node = program.namespace.lookup(nameInSource, this)
+                ?: throw UndefinedSymbolError(this)
+        val vardecl = node as? VarDecl
+        if(vardecl==null) {
+            return null
+        } else if(vardecl.type!= VarDeclType.CONST) {
+            return null
+        }
+        return vardecl.value?.constValue(program)
+    }
+
+    override fun toString(): String {
+        return "IdentifierRef($nameInSource)"
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name   // @todo is this correct all the time?
+
+    override fun inferType(program: Program): DataType? {
+        val targetStmt = targetStatement(program.namespace)
+        if(targetStmt is VarDecl) {
+            return targetStmt.datatype
+        } else {
+            throw FatalAstException("cannot get datatype from identifier reference ${this}, pos=$position")
+        }
+    }
+
+    fun memberOfStruct(namespace: INameScope) = this.targetVarDecl(namespace)?.struct
+
+    fun heapId(namespace: INameScope): Int {
+        val node = namespace.lookup(nameInSource, this) ?: throw UndefinedSymbolError(this)
+        val value = (node as? VarDecl)?.value ?: throw FatalAstException("requires a reference value")
+        return when (value) {
+            is IdentifierReference -> value.heapId(namespace)
+            is ReferenceLiteralValue -> value.heapId ?: throw FatalAstException("refLv is not on the heap: $value")
+            else -> throw FatalAstException("requires a reference value")
+        }
+    }
+
+    fun withPrefixedName(nameprefix: String): IdentifierReference {
+        val prefixed = nameInSource.dropLast(1) + listOf(nameprefix+nameInSource.last())
+        val new = IdentifierReference(prefixed, position)
+        new.parent = parent
+        return new
+    }
+}
+
+class FunctionCall(override var target: IdentifierReference,
+                   override var arglist: MutableList<Expression>,
+                   override val position: Position) : Expression(), IFunctionCall {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+        arglist.forEach { it.linkParents(this) }
+    }
+
+    override fun constValue(program: Program) = constValue(program, true)
+
+    private fun constValue(program: Program, withDatatypeCheck: Boolean): NumericLiteralValue? {
+        // if the function is a built-in function and the args are consts, should try to const-evaluate!
+        // lenghts of arrays and strings are constants that are determined at compile time!
+        if(target.nameInSource.size>1) return null
+        try {
+            var resultValue: NumericLiteralValue? = null
+            val func = BuiltinFunctions[target.nameInSource[0]]
+            if(func!=null) {
+                val exprfunc = func.constExpressionFunc
+                if(exprfunc!=null)
+                    resultValue = exprfunc(arglist, position, program)
+                else if(func.returntype==null)
+                    throw ExpressionError("builtin function ${target.nameInSource[0]} can't be used here because it doesn't return a value", position)
+            }
+
+            if(withDatatypeCheck) {
+                val resultDt = this.inferType(program)
+                if(resultValue==null || resultDt == resultValue.type)
+                    return resultValue
+                throw FatalAstException("evaluated const expression result value doesn't match expected datatype $resultDt, pos=$position")
+            } else {
+                return resultValue
+            }
+        }
+        catch(x: NotConstArgumentException) {
+            // const-evaluating the builtin function call failed.
+            return null
+        }
+    }
+
+    override fun toString(): String {
+        return "FunctionCall(target=$target, pos=$position)"
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || arglist.any{it.referencesIdentifiers(*name)}
+
+    override fun inferType(program: Program): DataType? {
+        val constVal = constValue(program ,false)
+        if(constVal!=null)
+            return constVal.type
+        val stmt = target.targetStatement(program.namespace) ?: return null
+        when (stmt) {
+            is BuiltinFunctionStatementPlaceholder -> {
+                if(target.nameInSource[0] == "set_carry" || target.nameInSource[0]=="set_irqd" ||
+                        target.nameInSource[0] == "clear_carry" || target.nameInSource[0]=="clear_irqd") {
+                    return null // these have no return value
+                }
+                return builtinFunctionReturnType(target.nameInSource[0], this.arglist, program)
+            }
+            is Subroutine -> {
+                if(stmt.returntypes.isEmpty())
+                    return null     // no return value
+                if(stmt.returntypes.size==1)
+                    return stmt.returntypes[0]
+                return null     // has multiple return types... so not a single resulting datatype possible
+            }
+            else -> return null
+        }
+    }
+}

compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt

@@ -0,0 +1,395 @@
+package prog8.ast.processing
+
+import prog8.ast.INameScope
+import prog8.ast.Module
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.compiler.HeapValues
+import prog8.compiler.target.c64.AssemblyProgram
+import prog8.functions.BuiltinFunctions
+
+
+internal class AstIdentifiersChecker(private val program: Program) : IAstModifyingVisitor {
+
+    private val checkResult: MutableList<AstException> = mutableListOf()
+
+    private var blocks = mutableMapOf<String, Block>()
+    private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
+
+    internal fun result(): List<AstException> {
+        return checkResult
+    }
+
+    private fun nameError(name: String, position: Position, existing: Statement) {
+        checkResult.add(NameError("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position))
+    }
+
+    override fun visit(module: Module) {
+        vardeclsToAdd.clear()
+        blocks.clear()  // blocks may be redefined within a different module
+        super.visit(module)
+        // add any new vardecls to the various scopes
+        for((where, decls) in vardeclsToAdd) {
+            where.statements.addAll(0, decls)
+            decls.forEach { it.linkParents(where as Node) }
+        }
+    }
+
+    override fun visit(block: Block): Statement {
+        val existing = blocks[block.name]
+        if(existing!=null)
+            nameError(block.name, block.position, existing)
+        else
+            blocks[block.name] = block
+
+        return super.visit(block)
+    }
+
+    override fun visit(functionCall: FunctionCall): Expression {
+        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
+            // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
+            val typecast = TypecastExpression(functionCall.arglist.single(), DataType.UBYTE, false, functionCall.position)
+            typecast.linkParents(functionCall.parent)
+            return super.visit(typecast)
+        }
+        return super.visit(functionCall)
+    }
+
+    override fun visit(decl: VarDecl): Statement {
+        // first, check if there are datatype errors on the vardecl
+        decl.datatypeErrors.forEach { checkResult.add(it) }
+
+        // now check the identifier
+        if(decl.name in BuiltinFunctions)
+            // the builtin functions can't be redefined
+            checkResult.add(NameError("builtin function cannot be redefined", decl.position))
+
+        if(decl.name in AssemblyProgram.opcodeNames)
+            checkResult.add(NameError("can't use a cpu opcode name as a symbol", decl.position))
+
+        // is it a struct variable? then define all its struct members as mangled names,
+        //    and include the original decl as well.
+        if(decl.datatype==DataType.STRUCT) {
+            if(decl.structHasBeenFlattened)
+                return super.visit(decl)    // don't do this multiple times
+
+            if(decl.struct==null) {
+                checkResult.add(NameError("undefined struct type", decl.position))
+                return super.visit(decl)
+            }
+
+            if(decl.struct!!.statements.any { (it as VarDecl).datatype !in NumericDatatypes})
+                return super.visit(decl)     // a non-numeric member, not supported. proper error is given by AstChecker later
+
+            if(decl.value is NumericLiteralValue) {
+                checkResult.add(ExpressionError("you cannot initialize a struct using a single value", decl.position))
+                return super.visit(decl)
+            }
+
+            val decls = decl.flattenStructMembers()
+            decls.add(decl)
+            val result = AnonymousScope(decls, decl.position)
+            result.linkParents(decl.parent)
+            return result
+        }
+
+        val existing = program.namespace.lookup(listOf(decl.name), decl)
+        if (existing != null && existing !== decl)
+            nameError(decl.name, decl.position, existing)
+
+        return super.visit(decl)
+    }
+
+    override fun visit(subroutine: Subroutine): Statement {
+        if(subroutine.name in AssemblyProgram.opcodeNames) {
+            checkResult.add(NameError("can't use a cpu opcode name as a symbol", subroutine.position))
+        } else if(subroutine.name in BuiltinFunctions) {
+            // the builtin functions can't be redefined
+            checkResult.add(NameError("builtin function cannot be redefined", subroutine.position))
+        } else {
+            // already reported elsewhere:
+            // if (subroutine.parameters.any { it.name in BuiltinFunctions })
+            //    checkResult.add(NameError("builtin function name cannot be used as parameter", subroutine.position))
+
+            val existing = program.namespace.lookup(listOf(subroutine.name), subroutine)
+            if (existing != null && existing !== subroutine)
+                nameError(subroutine.name, subroutine.position, existing)
+
+            // does the parameter redefine a variable declared elsewhere?
+            for(param in subroutine.parameters) {
+                val existingVar = subroutine.lookup(listOf(param.name), subroutine)
+                if (existingVar != null && existingVar.parent !== subroutine) {
+                    nameError(param.name, param.position, existingVar)
+                }
+            }
+
+            // check that there are no local variables, labels, or other subs that redefine the subroutine's parameters
+            val symbolsInSub = subroutine.allDefinedSymbols()
+            val namesInSub = symbolsInSub.map{ it.first }.toSet()
+            val paramNames = subroutine.parameters.map { it.name }.toSet()
+            val paramsToCheck = paramNames.intersect(namesInSub)
+            for(name in paramsToCheck) {
+                val labelOrVar = subroutine.getLabelOrVariable(name)
+                if(labelOrVar!=null && labelOrVar.position != subroutine.position)
+                    nameError(name, labelOrVar.position, subroutine)
+                val sub = subroutine.statements.singleOrNull { it is Subroutine && it.name==name}
+                if(sub!=null)
+                    nameError(name, sub.position, subroutine)
+            }
+
+            // inject subroutine params as local variables (if they're not there yet) (for non-kernel subroutines and non-asm parameters)
+            // NOTE:
+            // - numeric types BYTE and WORD and FLOAT are passed by value;
+            // - strings, arrays, matrices are passed by reference (their 16-bit address is passed as an uword parameter)
+            // - do NOT do this is the statement can be transformed into an asm subroutine later!
+            if(subroutine.asmAddress==null && !subroutine.canBeAsmSubroutine) {
+                if(subroutine.asmParameterRegisters.isEmpty()) {
+                    subroutine.parameters
+                            .filter { it.name !in namesInSub }
+                            .forEach {
+                                val vardecl = VarDecl(VarDeclType.VAR, it.type, ZeropageWish.NOT_IN_ZEROPAGE, null, it.name, null, null,
+                                        isArray = false, autogeneratedDontRemove = true, position = subroutine.position)
+                                vardecl.linkParents(subroutine)
+                                subroutine.statements.add(0, vardecl)
+                            }
+                }
+            }
+        }
+        return super.visit(subroutine)
+    }
+
+    override fun visit(label: Label): Statement {
+        if(label.name in AssemblyProgram.opcodeNames)
+            checkResult.add(NameError("can't use a cpu opcode name as a symbol", label.position))
+
+        if(label.name in BuiltinFunctions) {
+            // the builtin functions can't be redefined
+            checkResult.add(NameError("builtin function cannot be redefined", label.position))
+        } else {
+            val existing = program.namespace.lookup(listOf(label.name), label)
+            if (existing != null && existing !== label)
+                nameError(label.name, label.position, existing)
+        }
+        return super.visit(label)
+    }
+
+    override fun visit(forLoop: ForLoop): Statement {
+        // If the for loop has a decltype, it means to declare the loopvar inside the loop body
+        // rather than reusing an already declared loopvar from an outer scope.
+        // For loops that loop over an interable variable (instead of a range of numbers) get an
+        // additional interation count variable in their scope.
+        if(forLoop.loopRegister!=null) {
+            if(forLoop.decltype!=null)
+                checkResult.add(SyntaxError("register loop variables have a fixed implicit datatype", forLoop.position))
+            if(forLoop.loopRegister == Register.X)
+                printWarning("writing to the X register is dangerous, because it's used as an internal pointer", forLoop.position)
+        } else {
+            val loopVar = forLoop.loopVar
+            if (loopVar != null) {
+                val varName = loopVar.nameInSource.last()
+                if (forLoop.decltype != null) {
+                    val existing = if (forLoop.body.containsNoCodeNorVars()) null else forLoop.body.lookup(loopVar.nameInSource, forLoop.body.statements.first())
+                    if (existing == null) {
+                        // create the local scoped for loop variable itself
+                        val vardecl = VarDecl(VarDeclType.VAR, forLoop.decltype, forLoop.zeropage, null, varName, null, null,
+                                isArray = false, autogeneratedDontRemove = true, position = loopVar.position)
+                        vardecl.linkParents(forLoop.body)
+                        forLoop.body.statements.add(0, vardecl)
+                        loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
+                    } else if(existing.parent!==forLoop && existing.parent.parent!==forLoop) {
+                        checkResult.add(NameError("for loop var was already defined at ${existing.position}", loopVar.position))
+                    }
+                }
+
+                val validName = forLoop.body.name.replace("<", "").replace(">", "").replace("-", "")
+                val loopvarName = "prog8_loopvar_$validName"
+                if (forLoop.iterable !is RangeExpr) {
+                    val existing = if (forLoop.body.containsNoCodeNorVars()) null else forLoop.body.lookup(listOf(loopvarName), forLoop.body.statements.first())
+                    if (existing == null) {
+                        // create loop iteration counter variable (without value, to avoid an assignment)
+                        val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE, null, loopvarName, null, null,
+                                isArray = false, autogeneratedDontRemove = true, position = loopVar.position)
+                        vardecl.linkParents(forLoop.body)
+                        forLoop.body.statements.add(0, vardecl)
+                        loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
+                    }
+                }
+            }
+        }
+        return super.visit(forLoop)
+    }
+
+    override fun visit(assignTarget: AssignTarget): AssignTarget {
+        if(assignTarget.register== Register.X)
+            printWarning("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
+        return super.visit(assignTarget)
+    }
+
+    override fun visit(returnStmt: Return): Statement {
+        if(returnStmt.value!=null) {
+            // possibly adjust any literal values returned, into the desired returning data type
+            val subroutine = returnStmt.definingSubroutine()!!
+            if(subroutine.returntypes.size!=1)
+                return returnStmt  // mismatch in number of return values, error will be printed later.
+            val newValue: Expression
+            val lval = returnStmt.value as? NumericLiteralValue
+            if(lval!=null) {
+                val adjusted = lval.cast(subroutine.returntypes.single())
+                newValue = if(adjusted!=null && adjusted !== lval) adjusted else lval
+            } else {
+                newValue = returnStmt.value!!
+            }
+
+            returnStmt.value = newValue
+        }
+        return super.visit(returnStmt)
+    }
+
+    override fun visit(refLiteral: ReferenceLiteralValue): Expression {
+        val litval = super.visit(refLiteral)
+        if(litval is ReferenceLiteralValue) {
+            val vardecl = litval.parent as? VarDecl
+            if (litval.isString) {
+                // intern the string; move it into the heap
+                if (litval.str!!.length !in 1..255)
+                    checkResult.add(ExpressionError("string literal length must be between 1 and 255", litval.position))
+                else {
+                    litval.addToHeap(program.heap)
+                }
+                return if(vardecl!=null)
+                    litval
+                else
+                    makeIdentifierFromRefLv(litval)  // replace the literal string by a identifier reference.
+            } else if (litval.isArray) {
+                if (vardecl!=null) {
+                    return fixupArrayDatatype(litval, vardecl, program.heap)
+                } else {
+                    // fix the datatype of the array (also on the heap) to the 'biggest' datatype in the array
+                    // (we don't know the desired datatype here exactly so we guess)
+                    val datatype = determineArrayDt(litval.array!!) ?: return litval
+                    val litval2 = litval.cast(datatype)!!
+                    litval2.parent = litval.parent
+                    // finally, replace the literal array by a identifier reference.
+                    return makeIdentifierFromRefLv(litval2)
+                }
+            }
+        }
+
+        return litval
+    }
+
+    private fun determineArrayDt(array: Array<Expression>): DataType? {
+        val datatypesInArray = array.mapNotNull { it.inferType(program) }
+        if(datatypesInArray.isEmpty())
+            return null
+        if(DataType.FLOAT in datatypesInArray)
+            return DataType.ARRAY_F
+        if(DataType.WORD in datatypesInArray)
+            return DataType.ARRAY_W
+        if(DataType.UWORD in datatypesInArray)
+            return DataType.ARRAY_UW
+        if(DataType.BYTE in datatypesInArray)
+            return DataType.ARRAY_B
+        if(DataType.UBYTE in datatypesInArray)
+            return DataType.ARRAY_UB
+        return null
+    }
+
+    private fun makeIdentifierFromRefLv(refLiteral: ReferenceLiteralValue): IdentifierReference {
+        // a referencetype literal value that's not declared as a variable
+        // we need to introduce an auto-generated variable for this to be able to refer to the value
+        // note: if the var references the same literal value, it is not yet de-duplicated here.
+        refLiteral.addToHeap(program.heap)
+        val scope = refLiteral.definingScope()
+        var variable = VarDecl.createAuto(refLiteral, program.heap)
+        val existing = scope.lookup(listOf(variable.name), refLiteral)
+        variable = addVarDecl(scope, variable)
+        // replace the reference literal by a identifier reference
+        val identifier = IdentifierReference(listOf(variable.name), variable.position)
+        identifier.parent = refLiteral.parent
+        return identifier
+    }
+
+    override fun visit(addressOf: AddressOf): Expression {
+        // register the scoped name of the referenced identifier
+        val variable= addressOf.identifier.targetVarDecl(program.namespace) ?: return addressOf
+        addressOf.scopedname = variable.scopedname
+        return super.visit(addressOf)
+    }
+
+    override fun visit(structDecl: StructDecl): Statement {
+        for(member in structDecl.statements){
+            val decl = member as? VarDecl
+            if(decl!=null && decl.datatype !in NumericDatatypes)
+                checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+        }
+
+        return super.visit(structDecl)
+    }
+
+    override fun visit(expr: BinaryExpression): Expression {
+        return when {
+            expr.left is ReferenceLiteralValue ->
+                processBinaryExprWithReferenceVal(expr.left as ReferenceLiteralValue, expr.right, expr)
+            expr.right is ReferenceLiteralValue ->
+                processBinaryExprWithReferenceVal(expr.right as ReferenceLiteralValue, expr.left, expr)
+            else -> super.visit(expr)
+        }
+    }
+
+    private fun processBinaryExprWithReferenceVal(refLv: ReferenceLiteralValue, operand: Expression, expr: BinaryExpression): Expression {
+        // expressions on strings or arrays
+        if(refLv.isString) {
+            val constvalue = operand.constValue(program)
+            if(constvalue!=null) {
+                if (expr.operator == "*") {
+                    // repeat a string a number of times
+                    return ReferenceLiteralValue(refLv.inferType(program),
+                            refLv.str!!.repeat(constvalue.number.toInt()), null, null, expr.position)
+                }
+            }
+            if(expr.operator == "+" && operand is ReferenceLiteralValue) {
+                if (operand.isString) {
+                    // concatenate two strings
+                    return ReferenceLiteralValue(refLv.inferType(program),
+                            "${refLv.str}${operand.str}", null, null, expr.position)
+                }
+            }
+        }
+        return expr
+    }
+
+    private fun addVarDecl(scope: INameScope, variable: VarDecl): VarDecl {
+        if(scope !in vardeclsToAdd)
+            vardeclsToAdd[scope] = mutableListOf()
+        val declList = vardeclsToAdd.getValue(scope)
+        val existing = declList.singleOrNull { it.name==variable.name }
+        return if(existing!=null) {
+            existing
+        } else {
+            declList.add(variable)
+            variable
+        }
+    }
+
+}
+
+internal fun fixupArrayDatatype(array: ReferenceLiteralValue, vardecl: VarDecl, heap: HeapValues): ReferenceLiteralValue {
+    if(array.heapId!=null) {
+        val arrayDt = array.type
+        if(arrayDt!=vardecl.datatype) {
+            // fix the datatype of the array (also on the heap) to match the vardecl
+            val litval2 = array.cast(vardecl.datatype)!!
+            vardecl.value = litval2
+            litval2.linkParents(vardecl)
+            litval2.addToHeap(heap)     // TODO is the previous array discarded from the resulting asm code?
+            return litval2
+        }
+    } else {
+        array.addToHeap(heap)
+    }
+    return array
+}

compiler/src/prog8/ast/processing/AstRecursionChecker.kt

@@ -0,0 +1,117 @@
+package prog8.ast.processing
+
+import prog8.ast.INameScope
+import prog8.ast.base.AstException
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.statements.FunctionCallStatement
+import prog8.ast.statements.Subroutine
+
+
+internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisitor {
+    private val callGraph = DirectedGraph<INameScope>()
+
+    internal fun result(): List<AstException> {
+        val cycle = callGraph.checkForCycle()
+        if(cycle.isEmpty())
+            return emptyList()
+        val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
+        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        val scope = functionCallStatement.definingScope()
+        val targetStatement = functionCallStatement.target.targetStatement(namespace)
+        if(targetStatement!=null) {
+            val targetScope = when (targetStatement) {
+                is Subroutine -> targetStatement
+                else -> targetStatement.definingScope()
+            }
+            callGraph.add(scope, targetScope)
+        }
+        super.visit(functionCallStatement)
+    }
+
+    override fun visit(functionCall: FunctionCall) {
+        val scope = functionCall.definingScope()
+        val targetStatement = functionCall.target.targetStatement(namespace)
+        if(targetStatement!=null) {
+            val targetScope = when (targetStatement) {
+                is Subroutine -> targetStatement
+                else -> targetStatement.definingScope()
+            }
+            callGraph.add(scope, targetScope)
+        }
+        super.visit(functionCall)
+    }
+
+
+    private class DirectedGraph<VT> {
+        private val graph = mutableMapOf<VT, MutableSet<VT>>()
+        private var uniqueVertices = mutableSetOf<VT>()
+        val numVertices : Int
+            get() = uniqueVertices.size
+
+        fun add(from: VT, to: VT) {
+            var targets = graph[from]
+            if(targets==null) {
+                targets = mutableSetOf()
+                graph[from] = targets
+            }
+            targets.add(to)
+            uniqueVertices.add(from)
+            uniqueVertices.add(to)
+        }
+
+        fun print() {
+            println("#vertices: $numVertices")
+            graph.forEach { (from, to) ->
+                println("$from   CALLS:")
+                to.forEach { println("   $it") }
+            }
+            val cycle = checkForCycle()
+            if(cycle.isNotEmpty()) {
+                println("CYCLIC!  $cycle")
+            }
+        }
+
+        fun checkForCycle(): MutableList<VT> {
+            val visited = uniqueVertices.associateWith { false }.toMutableMap()
+            val recStack = uniqueVertices.associateWith { false }.toMutableMap()
+            val cycle = mutableListOf<VT>()
+            for(node in uniqueVertices) {
+                if(isCyclicUntil(node, visited, recStack, cycle))
+                    return cycle
+            }
+            return mutableListOf()
+        }
+
+        private fun isCyclicUntil(node: VT,
+                                  visited: MutableMap<VT, Boolean>,
+                                  recStack: MutableMap<VT, Boolean>,
+                                  cycleNodes: MutableList<VT>): Boolean {
+
+            if(recStack[node]==true) return true
+            if(visited[node]==true) return false
+
+            // mark current node as visited and add to recursion stack
+            visited[node] = true
+            recStack[node] = true
+
+            // recurse for all neighbours
+            val neighbors = graph[node]
+            if(neighbors!=null) {
+                for (neighbour in neighbors) {
+                    if (isCyclicUntil(neighbour, visited, recStack, cycleNodes)) {
+                        cycleNodes.add(node)
+                        return true
+                    }
+                }
+            }
+
+            // pop node from recursion stack
+            recStack[node] = false
+            return false
+        }
+    }
+
+}

compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt

@@ -0,0 +1,261 @@
+package prog8.ast.processing
+
+import prog8.ast.Module
+import prog8.ast.Program
+import prog8.ast.base.FatalAstException
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+interface IAstModifyingVisitor {
+    fun visit(program: Program) {
+        program.modules.forEach { visit(it) }
+    }
+
+    fun visit(module: Module) {
+        module.statements = module.statements.map { it.accept(this) }.toMutableList()
+    }
+
+    fun visit(expr: PrefixExpression): Expression {
+        expr.expression = expr.expression.accept(this)
+        return expr
+    }
+
+    fun visit(expr: BinaryExpression): Expression {
+        expr.left = expr.left.accept(this)
+        expr.right = expr.right.accept(this)
+        return expr
+    }
+
+    fun visit(directive: Directive): Statement {
+        return directive
+    }
+
+    fun visit(block: Block): Statement {
+        block.statements = block.statements.map { it.accept(this) }.toMutableList()
+        return block
+    }
+
+    fun visit(decl: VarDecl): Statement {
+        decl.value = decl.value?.accept(this)
+        decl.arraysize?.accept(this)
+        return decl
+    }
+
+    fun visit(subroutine: Subroutine): Statement {
+        subroutine.statements = subroutine.statements.map { it.accept(this) }.toMutableList()
+        return subroutine
+    }
+
+    fun visit(functionCall: FunctionCall): Expression {
+        val newtarget = functionCall.target.accept(this)
+        if(newtarget is IdentifierReference)
+            functionCall.target = newtarget
+        else
+            throw FatalAstException("cannot change class of function call target")
+        functionCall.arglist = functionCall.arglist.map { it.accept(this) }.toMutableList()
+        return functionCall
+    }
+
+    fun visit(functionCallStatement: FunctionCallStatement): Statement {
+        val newtarget = functionCallStatement.target.accept(this)
+        if(newtarget is IdentifierReference)
+            functionCallStatement.target = newtarget
+        else
+            throw FatalAstException("cannot change class of function call target")
+        functionCallStatement.arglist = functionCallStatement.arglist.map { it.accept(this) }.toMutableList()
+        return functionCallStatement
+    }
+
+    fun visit(identifier: IdentifierReference): Expression {
+        // note: this is an identifier that is used in an expression.
+        // other identifiers are simply part of the other statements (such as jumps, subroutine defs etc)
+        return identifier
+    }
+
+    fun visit(jump: Jump): Statement {
+        if(jump.identifier!=null) {
+            val ident = jump.identifier.accept(this)
+            if(ident is IdentifierReference && ident!==jump.identifier) {
+                return Jump(null, ident, null, jump.position)
+            }
+        }
+        return jump
+    }
+
+    fun visit(ifStatement: IfStatement): Statement {
+        ifStatement.condition = ifStatement.condition.accept(this)
+        ifStatement.truepart = ifStatement.truepart.accept(this) as AnonymousScope
+        ifStatement.elsepart = ifStatement.elsepart.accept(this) as AnonymousScope
+        return ifStatement
+    }
+
+    fun visit(branchStatement: BranchStatement): Statement {
+        branchStatement.truepart = branchStatement.truepart.accept(this) as AnonymousScope
+        branchStatement.elsepart = branchStatement.elsepart.accept(this) as AnonymousScope
+        return branchStatement
+    }
+
+    fun visit(range: RangeExpr): Expression {
+        range.from = range.from.accept(this)
+        range.to = range.to.accept(this)
+        range.step = range.step.accept(this)
+        return range
+    }
+
+    fun visit(label: Label): Statement {
+        return label
+    }
+
+    fun visit(literalValue: NumericLiteralValue): NumericLiteralValue {
+        return literalValue
+    }
+
+    fun visit(refLiteral: ReferenceLiteralValue): Expression {
+        if(refLiteral.array!=null) {
+            for(av in refLiteral.array.withIndex()) {
+                val newvalue = av.value.accept(this)
+                refLiteral.array[av.index] = newvalue
+            }
+        }
+        return refLiteral
+    }
+
+    fun visit(assignment: Assignment): Statement {
+        assignment.target = assignment.target.accept(this)
+        assignment.value = assignment.value.accept(this)
+        return assignment
+    }
+
+    fun visit(postIncrDecr: PostIncrDecr): Statement {
+        postIncrDecr.target = postIncrDecr.target.accept(this)
+        return postIncrDecr
+    }
+
+    fun visit(contStmt: Continue): Statement {
+        return contStmt
+    }
+
+    fun visit(breakStmt: Break): Statement {
+        return breakStmt
+    }
+
+    fun visit(forLoop: ForLoop): Statement {
+        val newloopvar = forLoop.loopVar?.accept(this)
+        when(newloopvar) {
+            is IdentifierReference -> forLoop.loopVar = newloopvar
+            null -> forLoop.loopVar = null
+            else -> throw FatalAstException("can't change class of loopvar")
+        }
+        forLoop.iterable = forLoop.iterable.accept(this)
+        forLoop.body = forLoop.body.accept(this) as AnonymousScope
+        return forLoop
+    }
+
+    fun visit(whileLoop: WhileLoop): Statement {
+        whileLoop.condition = whileLoop.condition.accept(this)
+        whileLoop.body = whileLoop.body.accept(this) as AnonymousScope
+        return whileLoop
+    }
+
+    fun visit(repeatLoop: RepeatLoop): Statement {
+        repeatLoop.untilCondition = repeatLoop.untilCondition.accept(this)
+        repeatLoop.body = repeatLoop.body.accept(this) as AnonymousScope
+        return repeatLoop
+    }
+
+    fun visit(returnStmt: Return): Statement {
+        returnStmt.value = returnStmt.value?.accept(this)
+        return returnStmt
+    }
+
+    fun visit(arrayIndexedExpression: ArrayIndexedExpression): ArrayIndexedExpression {
+        val ident = arrayIndexedExpression.identifier.accept(this)
+        if(ident is IdentifierReference)
+            arrayIndexedExpression.identifier = ident
+        arrayIndexedExpression.arrayspec.accept(this)
+        return arrayIndexedExpression
+    }
+
+    fun visit(assignTarget: AssignTarget): AssignTarget {
+        val ident = assignTarget.identifier?.accept(this)
+        when (ident) {
+            is IdentifierReference -> assignTarget.identifier = ident
+            null -> assignTarget.identifier = null
+            else -> throw FatalAstException("can't change class of assign target identifier")
+        }
+        assignTarget.arrayindexed = assignTarget.arrayindexed?.accept(this)
+        assignTarget.memoryAddress?.let { visit(it) }
+        return assignTarget
+    }
+
+    fun visit(scope: AnonymousScope): Statement {
+        scope.statements = scope.statements.map { it.accept(this) }.toMutableList()
+        return scope
+    }
+
+    fun visit(typecast: TypecastExpression): Expression {
+        typecast.expression = typecast.expression.accept(this)
+        return typecast
+    }
+
+    fun visit(memread: DirectMemoryRead): Expression {
+        memread.addressExpression = memread.addressExpression.accept(this)
+        return memread
+    }
+
+    fun visit(memwrite: DirectMemoryWrite) {
+        memwrite.addressExpression = memwrite.addressExpression.accept(this)
+    }
+
+    fun visit(addressOf: AddressOf): Expression {
+        val ident = addressOf.identifier.accept(this)
+        if(ident is IdentifierReference)
+            addressOf.identifier = ident
+        else
+            throw FatalAstException("can't change class of addressof identifier")
+        return addressOf
+    }
+
+    fun visit(inlineAssembly: InlineAssembly): Statement {
+        return inlineAssembly
+    }
+
+    fun visit(registerExpr: RegisterExpr): Expression {
+        return registerExpr
+    }
+
+    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder): Statement {
+        return builtinFunctionStatementPlaceholder
+    }
+
+    fun visit(nopStatement: NopStatement): Statement {
+        return nopStatement
+    }
+
+    fun visit(whenStatement: WhenStatement): Statement {
+        whenStatement.condition = whenStatement.condition.accept(this)
+        whenStatement.choices.forEach { it.accept(this) }
+        return whenStatement
+    }
+
+    fun visit(whenChoice: WhenChoice) {
+        whenChoice.values = whenChoice.values?.map { it.accept(this) }
+        val stmt = whenChoice.statements.accept(this)
+        if(stmt is AnonymousScope)
+            whenChoice.statements = stmt
+        else {
+            whenChoice.statements = AnonymousScope(mutableListOf(stmt), stmt.position)
+            whenChoice.statements.linkParents(whenChoice)
+        }
+    }
+
+    fun visit(structDecl: StructDecl): Statement {
+        structDecl.statements = structDecl.statements.map{ it.accept(this) }.toMutableList()
+        return structDecl
+    }
+
+    fun visit(structLv: StructLiteralValue): Expression {
+        structLv.values = structLv.values.map { it.accept(this) }
+        return structLv
+    }
+}

compiler/src/prog8/ast/processing/IAstVisitor.kt

@@ -0,0 +1,181 @@
+package prog8.ast.processing
+
+import prog8.ast.Module
+import prog8.ast.Program
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+interface IAstVisitor {
+    fun visit(program: Program) {
+        program.modules.forEach { visit(it) }
+    }
+
+    fun visit(module: Module) {
+        module.statements.forEach{ it.accept(this) }
+    }
+
+    fun visit(expr: PrefixExpression) {
+        expr.expression.accept(this)
+    }
+
+    fun visit(expr: BinaryExpression) {
+        expr.left.accept(this)
+        expr.right.accept(this)
+    }
+
+    fun visit(directive: Directive) {
+    }
+
+    fun visit(block: Block) {
+        block.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(decl: VarDecl) {
+        decl.value?.accept(this)
+        decl.arraysize?.accept(this)
+    }
+
+    fun visit(subroutine: Subroutine) {
+        subroutine.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(functionCall: FunctionCall) {
+        functionCall.target.accept(this)
+        functionCall.arglist.forEach { it.accept(this) }
+    }
+
+    fun visit(functionCallStatement: FunctionCallStatement) {
+        functionCallStatement.target.accept(this)
+        functionCallStatement.arglist.forEach { it.accept(this) }
+    }
+
+    fun visit(identifier: IdentifierReference) {
+    }
+
+    fun visit(jump: Jump) {
+        jump.identifier?.accept(this)
+    }
+
+    fun visit(ifStatement: IfStatement) {
+        ifStatement.condition.accept(this)
+        ifStatement.truepart.accept(this)
+        ifStatement.elsepart.accept(this)
+    }
+
+    fun visit(branchStatement: BranchStatement) {
+        branchStatement.truepart.accept(this)
+        branchStatement.elsepart.accept(this)
+    }
+
+    fun visit(range: RangeExpr) {
+        range.from.accept(this)
+        range.to.accept(this)
+        range.step.accept(this)
+    }
+
+    fun visit(label: Label) {
+    }
+
+    fun visit(numLiteral: NumericLiteralValue) {
+    }
+
+    fun visit(refLiteral: ReferenceLiteralValue) {
+        refLiteral.array?.let { it.forEach { v->v.accept(this) }}
+    }
+
+    fun visit(assignment: Assignment) {
+        assignment.target.accept(this)
+        assignment.value.accept(this)
+    }
+
+    fun visit(postIncrDecr: PostIncrDecr) {
+        postIncrDecr.target.accept(this)
+    }
+
+    fun visit(contStmt: Continue) {
+    }
+
+    fun visit(breakStmt: Break) {
+    }
+
+    fun visit(forLoop: ForLoop) {
+        forLoop.loopVar?.accept(this)
+        forLoop.iterable.accept(this)
+        forLoop.body.accept(this)
+    }
+
+    fun visit(whileLoop: WhileLoop) {
+        whileLoop.condition.accept(this)
+        whileLoop.body.accept(this)
+    }
+
+    fun visit(repeatLoop: RepeatLoop) {
+        repeatLoop.untilCondition.accept(this)
+        repeatLoop.body.accept(this)
+    }
+
+    fun visit(returnStmt: Return) {
+        returnStmt.value?.accept(this)
+    }
+
+    fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
+        arrayIndexedExpression.identifier.accept(this)
+        arrayIndexedExpression.arrayspec.accept(this)
+    }
+
+    fun visit(assignTarget: AssignTarget) {
+        assignTarget.arrayindexed?.accept(this)
+        assignTarget.identifier?.accept(this)
+        assignTarget.memoryAddress?.accept(this)
+    }
+
+    fun visit(scope: AnonymousScope) {
+        scope.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(typecast: TypecastExpression) {
+        typecast.expression.accept(this)
+    }
+
+    fun visit(memread: DirectMemoryRead) {
+        memread.addressExpression.accept(this)
+    }
+
+    fun visit(memwrite: DirectMemoryWrite) {
+        memwrite.addressExpression.accept(this)
+    }
+
+    fun visit(addressOf: AddressOf) {
+        addressOf.identifier.accept(this)
+    }
+
+    fun visit(inlineAssembly: InlineAssembly) {
+    }
+
+    fun visit(registerExpr: RegisterExpr) {
+    }
+
+    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
+    }
+
+    fun visit(nopStatement: NopStatement) {
+    }
+
+    fun visit(whenStatement: WhenStatement) {
+        whenStatement.condition.accept(this)
+        whenStatement.choices.forEach { it.accept(this) }
+    }
+
+    fun visit(whenChoice: WhenChoice) {
+        whenChoice.values?.forEach { it.accept(this) }
+        whenChoice.statements.accept(this)
+    }
+
+    fun visit(structDecl: StructDecl) {
+        structDecl.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(structLv: StructLiteralValue) {
+        structLv.values.forEach { it.accept(this) }
+    }
+}

compiler/src/prog8/ast/processing/ImportedModuleDirectiveRemover.kt

@@ -1,35 +1,28 @@
-package prog8.ast
+package prog8.ast.processing
 
+import prog8.ast.Module
+import prog8.ast.base.SyntaxError
+import prog8.ast.base.printWarning
+import prog8.ast.statements.Directive
+import prog8.ast.statements.Statement
 
-/**
- * Checks that are specific for imported modules.
- */
-
-fun Module.checkImportedValid() {
-    val checker = ImportedAstChecker()
-    this.linkParents()
-    this.process(checker)
-    printErrors(checker.result(), name)
-}
-
-
-private class ImportedAstChecker : IAstProcessor {
+internal class ImportedModuleDirectiveRemover : IAstModifyingVisitor {
     private val checkResult: MutableList<SyntaxError> = mutableListOf()
 
-    fun result(): List<SyntaxError> {
+    internal fun result(): List<SyntaxError> {
         return checkResult
     }
 
     /**
-     * Module check: most global directives don't apply for imported modules
+     * Most global directives don't apply for imported modules, so remove them
      */
-    override fun process(module: Module) {
-        super.process(module)
-        val newStatements : MutableList<IStatement> = mutableListOf()
+    override fun visit(module: Module) {
+        super.visit(module)
+        val newStatements : MutableList<Statement> = mutableListOf()
 
         val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
         for (sourceStmt in module.statements) {
-            val stmt = sourceStmt.process(this)
+            val stmt = sourceStmt.accept(this)
             if(stmt is Directive && stmt.parent is Module) {
                 if(stmt.directive in moduleLevelDirectives) {
                     printWarning("ignoring module directive because it was imported", stmt.position, stmt.directive)

compiler/src/prog8/ast/processing/StatementReorderer.kt

@@ -0,0 +1,400 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.base.DataType
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.initvarsSubName
+import prog8.ast.base.printWarning
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.functions.BuiltinFunctions
+
+
+fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
+    val identifier = structAssignment.target.identifier!!
+    val identifierName = identifier.nameInSource.single()
+    val targetVar = identifier.targetVarDecl(program.namespace)!!
+    val struct = targetVar.struct!!
+    when {
+        structAssignment.value is IdentifierReference -> {
+            val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!!
+            if (sourceVar.struct == null)
+                throw FatalAstException("can only assign arrays or structs to structs")
+            // struct memberwise copy
+            val sourceStruct = sourceVar.struct!!
+            if(sourceStruct!==targetVar.struct) {
+                // structs are not the same in assignment
+                return listOf()     // error will be printed elsewhere
+            }
+            return struct.statements.zip(sourceStruct.statements).map { member ->
+                val targetDecl = member.first as VarDecl
+                val sourceDecl = member.second as VarDecl
+                if(targetDecl.name != sourceDecl.name)
+                    throw FatalAstException("struct member mismatch")
+                val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+                val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+                val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
+                val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
+                val assign = Assignment(AssignTarget(null, idref, null, null, structAssignment.position),
+                        null, sourceIdref, member.second.position)
+                assign.linkParents(structAssignment)
+                assign
+            }
+        }
+        structAssignment.value is StructLiteralValue -> {
+            throw IllegalArgumentException("not going to flatten a structLv assignment here")
+        }
+        else -> throw FatalAstException("strange struct value")
+    }
+}
+
+
+internal class StatementReorderer(private val program: Program): IAstModifyingVisitor {
+    // Reorders the statements in a way the compiler needs.
+    // - 'main' block must be the very first statement UNLESS it has an address set.
+    // - blocks are ordered by address, where blocks without address are put at the end.
+    // - in every scope:
+    //      -- the directives '%output', '%launcher', '%zeropage', '%zpreserved', '%address' and '%option' will come first.
+    //      -- all vardecls then follow.
+    //      -- the remaining statements then follow in their original order.
+    //
+    // - the 'start' subroutine in the 'main' block will be moved to the top immediately following the directives.
+    // - all other subroutines will be moved to the end of their block.
+    // - sorts the choices in when statement.
+    //
+    // Also, makes sure any value assignments get the proper type casts if needed to cast them into the target variable's type.
+    // (this includes function call arguments)
+
+    private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%option")
+
+    override fun visit(module: Module) {
+        super.visit(module)
+
+        val (blocks, other) = module.statements.partition { it is Block }
+        module.statements = other.asSequence().plus(blocks.sortedBy { (it as Block).address ?: Int.MAX_VALUE }).toMutableList()
+
+        // make sure user-defined blocks come BEFORE library blocks, and move the "main" block to the top of everything
+        val nonLibraryBlocks = module.statements.withIndex()
+                .filter { it.value is Block && !(it.value as Block).isInLibrary }
+                .map { it.index to it.value }
+                .reversed()
+        for(nonLibBlock in nonLibraryBlocks)
+            module.statements.removeAt(nonLibBlock.first)
+        for(nonLibBlock in nonLibraryBlocks)
+            module.statements.add(0, nonLibBlock.second)
+        val mainBlock = module.statements.singleOrNull { it is Block && it.name=="main" }
+        if(mainBlock!=null && (mainBlock as Block).address==null) {
+            module.remove(mainBlock)
+            module.statements.add(0, mainBlock)
+        }
+
+        val varDecls = module.statements.filterIsInstance<VarDecl>()
+        module.statements.removeAll(varDecls)
+        module.statements.addAll(0, varDecls)
+
+        val directives = module.statements.filter {it is Directive && it.directive in directivesToMove}
+        module.statements.removeAll(directives)
+        module.statements.addAll(0, directives)
+    }
+
+    override fun visit(block: Block): Statement {
+
+        val subroutines = block.statements.filterIsInstance<Subroutine>()
+        var numSubroutinesAtEnd = 0
+        // move all subroutines to the end of the block
+        for (subroutine in subroutines) {
+            if(subroutine.name!="start" || block.name!="main") {
+                block.remove(subroutine)
+                block.statements.add(subroutine)
+            }
+            numSubroutinesAtEnd++
+        }
+        // move the "start" subroutine to the top
+        if(block.name=="main") {
+            block.statements.singleOrNull { it is Subroutine && it.name == "start" } ?.let {
+                block.remove(it)
+                block.statements.add(0, it)
+                numSubroutinesAtEnd--
+            }
+        }
+
+        // make sure there is a 'return' in front of the first subroutine
+        // (if it isn't the first statement in the block itself, and isn't the program's entrypoint)
+        if(numSubroutinesAtEnd>0 && block.statements.size > (numSubroutinesAtEnd+1)) {
+            val firstSub = block.statements[block.statements.size - numSubroutinesAtEnd] as Subroutine
+            if(firstSub.name != "start" && block.name != "main") {
+                val stmtBeforeFirstSub = block.statements[block.statements.size - numSubroutinesAtEnd - 1]
+                if (stmtBeforeFirstSub !is Return
+                        && stmtBeforeFirstSub !is Jump
+                        && stmtBeforeFirstSub !is Subroutine
+                        && stmtBeforeFirstSub !is BuiltinFunctionStatementPlaceholder) {
+                    val ret = Return(null, stmtBeforeFirstSub.position)
+                    ret.linkParents(block)
+                    block.statements.add(block.statements.size - numSubroutinesAtEnd, ret)
+                }
+            }
+        }
+
+        val varDecls = block.statements.filterIsInstance<VarDecl>()
+        block.statements.removeAll(varDecls)
+        block.statements.addAll(0, varDecls)
+        val directives = block.statements.filter {it is Directive && it.directive in directivesToMove}
+        block.statements.removeAll(directives)
+        block.statements.addAll(0, directives)
+        block.linkParents(block.parent)
+
+        // create subroutine that initializes the block's variables (if any)
+        val varInits = block.statements.withIndex().filter { it.value is VariableInitializationAssignment }
+        if(varInits.isNotEmpty()) {
+            val statements = varInits.map{it.value}.toMutableList()
+            val varInitSub = Subroutine(initvarsSubName, emptyList(), emptyList(), emptyList(), emptyList(),
+                    emptySet(), null, false, statements, block.position)
+            varInitSub.keepAlways = true
+            varInitSub.linkParents(block)
+            block.statements.add(varInitSub)
+
+            // remove the varinits from the block's statements
+            for(index in varInits.map{it.index}.reversed())
+                block.statements.removeAt(index)
+        }
+
+        return super.visit(block)
+    }
+
+    override fun visit(subroutine: Subroutine): Statement {
+        super.visit(subroutine)
+
+        val varDecls = subroutine.statements.filterIsInstance<VarDecl>()
+        subroutine.statements.removeAll(varDecls)
+        subroutine.statements.addAll(0, varDecls)
+        val directives = subroutine.statements.filter {it is Directive && it.directive in directivesToMove}
+        subroutine.statements.removeAll(directives)
+        subroutine.statements.addAll(0, directives)
+
+        if(subroutine.returntypes.isEmpty()) {
+            // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
+            // and if an assembly block doesn't contain a rts/rti
+            if(subroutine.asmAddress==null && subroutine.amountOfRtsInAsm()==0) {
+                if (subroutine.statements.lastOrNull {it !is VarDecl } !is Return) {
+                    val returnStmt = Return(null, subroutine.position)
+                    returnStmt.linkParents(subroutine)
+                    subroutine.statements.add(returnStmt)
+                }
+            }
+        }
+
+        return subroutine
+    }
+
+    override fun visit(expr: BinaryExpression): Expression {
+        val expr2 = super.visit(expr)
+        if(expr2 !is BinaryExpression)
+            return expr2
+        val leftDt = expr2.left.inferType(program)
+        val rightDt = expr2.right.inferType(program)
+        if(leftDt!=null && rightDt!=null && leftDt!=rightDt) {
+            // determine common datatype and add typecast as required to make left and right equal types
+            val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt, rightDt, expr2.left, expr2.right)
+            if(toFix!=null) {
+                when {
+                    toFix===expr2.left -> {
+                        expr2.left = TypecastExpression(expr2.left, commonDt, true, expr2.left.position)
+                        expr2.left.linkParents(expr2)
+                    }
+                    toFix===expr2.right -> {
+                        expr2.right = TypecastExpression(expr2.right, commonDt, true, expr2.right.position)
+                        expr2.right.linkParents(expr2)
+                    }
+                    else -> throw FatalAstException("confused binary expression side")
+                }
+            }
+        }
+        return expr2
+    }
+
+    override fun visit(assignment: Assignment): Statement {
+        val assg = super.visit(assignment)
+        if(assg !is Assignment)
+            return assg
+
+        // see if a typecast is needed to convert the value's type into the proper target type
+        val valuetype = assg.value.inferType(program)
+        val targettype = assg.target.inferType(program, assg)
+        if(targettype!=null && valuetype!=null) {
+            if(valuetype!=targettype) {
+                if (valuetype isAssignableTo targettype) {
+                    assg.value = TypecastExpression(assg.value, targettype, true, assg.value.position)
+                    assg.value.linkParents(assg)
+                }
+                // if they're not assignable, we'll get a proper error later from the AstChecker
+            }
+        }
+
+        // struct assignments will be flattened (if it's not a struct literal)
+        if(valuetype==DataType.STRUCT && targettype==DataType.STRUCT) {
+            if(assg.value is StructLiteralValue)
+                return assg  // do NOT flatten it at this point!! (the compiler will take care if it, later, if needed)
+
+            val assignments = flattenStructAssignmentFromIdentifier(assg, program)    //   'structvar1 = structvar2'
+            return if(assignments.isEmpty()) {
+                // something went wrong (probably incompatible struct types)
+                // we'll get an error later from the AstChecker
+                assg
+            } else {
+                val scope = AnonymousScope(assignments.toMutableList(), assg.position)
+                scope.linkParents(assg.parent)
+                scope
+            }
+        }
+
+        if(assg.aug_op!=null) {
+            // transform augmented assg into normal assg so we have one case less to deal with later
+            val newTarget: Expression =
+                    when {
+                        assg.target.register != null -> RegisterExpr(assg.target.register!!, assg.target.position)
+                        assg.target.identifier != null -> assg.target.identifier!!
+                        assg.target.arrayindexed != null -> assg.target.arrayindexed!!
+                        assg.target.memoryAddress != null -> DirectMemoryRead(assg.target.memoryAddress!!.addressExpression, assg.value.position)
+                        else -> throw FatalAstException("strange assg")
+                    }
+
+            val expression = BinaryExpression(newTarget, assg.aug_op.substringBeforeLast('='), assg.value, assg.position)
+            expression.linkParents(assg.parent)
+            val convertedAssignment = Assignment(assg.target, null, expression, assg.position)
+            convertedAssignment.linkParents(assg.parent)
+            return super.visit(convertedAssignment)
+        }
+
+        return assg
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
+        checkFunctionCallArguments(functionCallStatement, functionCallStatement.definingScope())
+        return super.visit(functionCallStatement)
+    }
+
+    override fun visit(functionCall: FunctionCall): Expression {
+        checkFunctionCallArguments(functionCall, functionCall.definingScope())
+        return super.visit(functionCall)
+    }
+
+    private fun checkFunctionCallArguments(call: IFunctionCall, scope: INameScope) {
+        // see if a typecast is needed to convert the arguments into the required parameter's type
+        when(val sub = call.target.targetStatement(scope)) {
+            is Subroutine -> {
+                for(arg in sub.parameters.zip(call.arglist.withIndex())) {
+                    val argtype = arg.second.value.inferType(program)
+                    if(argtype!=null) {
+                        val requiredType = arg.first.type
+                        if (requiredType != argtype) {
+                            if (argtype isAssignableTo requiredType) {
+                                val typecasted = TypecastExpression(arg.second.value, requiredType, true, arg.second.value.position)
+                                typecasted.linkParents(arg.second.value.parent)
+                                call.arglist[arg.second.index] = typecasted
+                            }
+                            // if they're not assignable, we'll get a proper error later from the AstChecker
+                        }
+                    }
+                }
+            }
+            is BuiltinFunctionStatementPlaceholder -> {
+                val func = BuiltinFunctions.getValue(sub.name)
+                if(func.pure) {
+                    // non-pure functions don't get automatic typecasts because sometimes they act directly on their parameters
+                    for (arg in func.parameters.zip(call.arglist.withIndex())) {
+                        val argtype = arg.second.value.inferType(program)
+                        if (argtype != null) {
+                            if (arg.first.possibleDatatypes.any { argtype == it })
+                                continue
+                            for (possibleType in arg.first.possibleDatatypes) {
+                                if (argtype isAssignableTo possibleType) {
+                                    val typecasted = TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position)
+                                    typecasted.linkParents(arg.second.value.parent)
+                                    call.arglist[arg.second.index] = typecasted
+                                    break
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            null -> {}
+            else -> TODO("call to something weird $sub   ${call.target}")
+        }
+    }
+
+    override fun visit(typecast: TypecastExpression): Expression {
+        // warn about any implicit type casts to Float, because that may not be intended
+        if(typecast.implicit && typecast.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
+            printWarning("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
+        }
+        return super.visit(typecast)
+    }
+
+    override fun visit(memread: DirectMemoryRead): Expression {
+        // make sure the memory address is an uword
+        val dt = memread.addressExpression.inferType(program)
+        if(dt!=DataType.UWORD) {
+            val literaladdr = memread.addressExpression as? NumericLiteralValue
+            if(literaladdr!=null) {
+                memread.addressExpression = literaladdr.cast(DataType.UWORD)!!
+            } else {
+                memread.addressExpression = TypecastExpression(memread.addressExpression, DataType.UWORD, true, memread.addressExpression.position)
+                memread.addressExpression.parent = memread
+            }
+        }
+        return super.visit(memread)
+    }
+
+    override fun visit(memwrite: DirectMemoryWrite) {
+        val dt = memwrite.addressExpression.inferType(program)
+        if(dt!=DataType.UWORD) {
+            val literaladdr = memwrite.addressExpression as? NumericLiteralValue
+            if(literaladdr!=null) {
+                memwrite.addressExpression = literaladdr.cast(DataType.UWORD)!!
+            } else {
+                memwrite.addressExpression = TypecastExpression(memwrite.addressExpression, DataType.UWORD, true, memwrite.addressExpression.position)
+                memwrite.addressExpression.parent = memwrite
+            }
+        }
+        super.visit(memwrite)
+    }
+
+    override fun visit(structLv: StructLiteralValue): Expression {
+        val litval = super.visit(structLv)
+        if(litval !is StructLiteralValue)
+            return litval
+
+        val decl = litval.parent as? VarDecl
+        if(decl != null) {
+            val struct = decl.struct
+            if(struct != null) {
+                addTypecastsIfNeeded(litval, struct)
+            }
+        } else {
+            val assign = litval.parent as? Assignment
+            if (assign != null) {
+                val decl2 = assign.target.identifier?.targetVarDecl(program.namespace)
+                if(decl2 != null) {
+                    val struct = decl2.struct
+                    if(struct != null) {
+                        addTypecastsIfNeeded(litval, struct)
+                    }
+                }
+            }
+        }
+
+        return litval
+    }
+
+    private fun addTypecastsIfNeeded(structLv: StructLiteralValue, struct: StructDecl) {
+        structLv.values = struct.statements.zip(structLv.values).map {
+            val memberDt = (it.first as VarDecl).datatype
+            val valueDt = it.second.inferType(program)
+            if (valueDt != memberDt)
+                TypecastExpression(it.second, memberDt, true, it.second.position)
+            else
+                it.second
+        }
+    }
+}

compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt

@@ -0,0 +1,163 @@
+package prog8.ast.processing
+
+import prog8.ast.INameScope
+import prog8.ast.Module
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.compiler.CompilerException
+import prog8.functions.BuiltinFunctions
+import prog8.functions.FunctionSignature
+
+
+internal class VarInitValueAndAddressOfCreator(private val program: Program): IAstModifyingVisitor {
+    // For VarDecls that declare an initialization value:
+    // Replace the vardecl with an assignment (to set the initial value),
+    // and add a new vardecl with the default constant value of that type (usually zero) to the scope.
+    // This makes sure the variables get reset to the intended value on a next run of the program.
+    // Variable decls without a value don't get this treatment, which means they retain the last
+    // value they had when restarting the program.
+    // This is done in a separate step because it interferes with the namespace lookup of symbols
+    // in other ast processors.
+
+    // Also takes care to insert AddressOf (&) expression where required (string params to a UWORD function param etc).
+
+    private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
+
+    override fun visit(module: Module) {
+        vardeclsToAdd.clear()
+        super.visit(module)
+        // add any new vardecls to the various scopes
+        for((where, decls) in vardeclsToAdd) {
+            where.statements.addAll(0, decls)
+            decls.forEach { it.linkParents(where as Node) }
+        }
+    }
+
+    override fun visit(decl: VarDecl): Statement {
+        super.visit(decl)
+
+        if(decl.isArray && decl.value==null) {
+            // array datatype without initialization value, add list of zeros
+            val arraysize = decl.arraysize!!.size()!!
+            val array = ReferenceLiteralValue(decl.datatype, null,
+                    Array(arraysize) { NumericLiteralValue.optimalInteger(0, decl.position) },
+                    null, decl.position)
+            array.addToHeap(program.heap)
+            decl.value = array
+        }
+
+        if(decl.type!= VarDeclType.VAR || decl.value==null)
+            return decl
+
+        if(decl.datatype in NumericDatatypes) {
+            val scope = decl.definingScope()
+            addVarDecl(scope, decl.asDefaultValueDecl(null))
+            val declvalue = decl.value!!
+            val value =
+                    if(declvalue is NumericLiteralValue) {
+                        val converted = declvalue.cast(decl.datatype)
+                        converted ?: declvalue
+                    }
+                    else
+                        declvalue
+            val identifierName = listOf(decl.name)    // this was: (scoped name) decl.scopedname.split(".")
+            return VariableInitializationAssignment(
+                    AssignTarget(null, IdentifierReference(identifierName, decl.position), null, null, decl.position),
+                    null,
+                    value,
+                    decl.position
+            )
+        }
+
+        return decl
+    }
+
+    override fun visit(functionCall: FunctionCall): Expression {
+        var parentStatement: Node = functionCall
+        while(parentStatement !is Statement)
+            parentStatement = parentStatement.parent
+        val targetStatement = functionCall.target.targetSubroutine(program.namespace)
+        if(targetStatement!=null) {
+            addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, parentStatement)
+        } else {
+            val builtinFunc = BuiltinFunctions[functionCall.target.nameInSource.joinToString (".")]
+            if(builtinFunc!=null)
+                addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCall.arglist, parentStatement)
+        }
+        return functionCall
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
+        val targetStatement = functionCallStatement.target.targetSubroutine(program.namespace)
+        if(targetStatement!=null) {
+            addAddressOfExprIfNeeded(targetStatement, functionCallStatement.arglist, functionCallStatement)
+        } else {
+            val builtinFunc = BuiltinFunctions[functionCallStatement.target.nameInSource.joinToString (".")]
+            if(builtinFunc!=null)
+                addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCallStatement.arglist, functionCallStatement)
+        }
+        return functionCallStatement
+    }
+
+    private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<Expression>, parent: Statement) {
+        // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
+        for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
+            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) {
+                if(argparam.second is AddressOf)
+                    continue
+                val idref = argparam.second as? IdentifierReference
+                val strvalue = argparam.second as? ReferenceLiteralValue
+                if(idref!=null) {
+                    val variable = idref.targetVarDecl(program.namespace)
+                    if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) {
+                        val pointerExpr = AddressOf(idref, idref.position)
+                        pointerExpr.scopedname = parent.makeScopedName(idref.nameInSource.single())
+                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
+                        arglist[argparam.first.index] = pointerExpr
+                    }
+                }
+                else if(strvalue!=null) {
+                    if(strvalue.isString) {
+                        // add a vardecl so that the autovar can be resolved in later lookups
+                        val variable = VarDecl.createAuto(strvalue, program.heap)
+                        addVarDecl(strvalue.definingScope(), variable)
+                        // replace the argument with &autovar
+                        val autoHeapvarRef = IdentifierReference(listOf(variable.name), strvalue.position)
+                        val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
+                        pointerExpr.scopedname = parent.makeScopedName(variable.name)
+                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
+                        arglist[argparam.first.index] = pointerExpr
+                    }
+                }
+            }
+        }
+    }
+
+    private fun addAddressOfExprIfNeededForBuiltinFuncs(signature: FunctionSignature, args: MutableList<Expression>, parent: Statement) {
+        for(arg in args.withIndex().zip(signature.parameters)) {
+            val argvalue = arg.first.value
+            val argDt = argvalue.inferType(program)
+            if(DataType.UWORD in arg.second.possibleDatatypes && argDt in PassByReferenceDatatypes) {
+                if(argvalue !is IdentifierReference)
+                    throw CompilerException("pass-by-reference parameter isn't an identifier? $argvalue")
+                val addrOf = AddressOf(argvalue, argvalue.position)
+                args[arg.first.index] = addrOf
+                addrOf.scopedname = parent.makeScopedName(argvalue.nameInSource.single())
+                addrOf.linkParents(parent)
+            }
+        }
+    }
+
+
+    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
+        if(scope !in vardeclsToAdd)
+            vardeclsToAdd[scope] = mutableListOf()
+        val declList = vardeclsToAdd.getValue(scope)
+        if(declList.all{it.name!=variable.name})
+            declList.add(variable)
+    }
+
+}

compiler/src/prog8/ast/statements/AstStatements.kt

@@ -0,0 +1,840 @@
+package prog8.ast.statements
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.compiler.HeapValues
+
+
+sealed class Statement : Node {
+    abstract fun accept(visitor: IAstModifyingVisitor) : Statement
+    abstract fun accept(visitor: IAstVisitor)
+    fun makeScopedName(name: String): String {
+        // easy way out is to always return the full scoped name.
+        // it would be nicer to find only the minimal prefixed scoped name, but that's too much hassle for now.
+        // and like this, we can cache the name even,
+        // like in a lazy property on the statement object itself (label, subroutine, vardecl)
+        val scope = mutableListOf<String>()
+        var statementScope = this.parent
+        while(statementScope !is ParentSentinel && statementScope !is Module) {
+            if(statementScope is INameScope) {
+                scope.add(0, statementScope.name)
+            }
+            statementScope = statementScope.parent
+        }
+        if(name.isNotEmpty())
+            scope.add(name)
+        return scope.joinToString(".")
+    }
+
+    abstract val expensiveToInline: Boolean
+
+    fun definingBlock(): Block {
+        if(this is Block)
+            return this
+        return findParentNode<Block>(this)!!
+    }
+}
+
+
+class BuiltinFunctionStatementPlaceholder(val name: String, override val position: Position) : Statement() {
+    override var parent: Node = ParentSentinel
+    override fun linkParents(parent: Node) {}
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun definingScope(): INameScope = BuiltinFunctionScopePlaceholder
+    override val expensiveToInline = false
+}
+
+
+data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean)
+
+
+class Block(override val name: String,
+            val address: Int?,
+            override var statements: MutableList<Statement>,
+            val isInLibrary: Boolean,
+            override val position: Position) : Statement(), INameScope {
+    override lateinit var parent: Node
+    override val expensiveToInline
+        get() = statements.any { it.expensiveToInline }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach {it.linkParents(this)}
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Block(name=$name, address=$address, ${statements.size} statements)"
+    }
+
+    fun options() = statements.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.map {it.name!!}.toSet()
+}
+
+data class Directive(val directive: String, val args: List<DirectiveArg>, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        args.forEach{it.linkParents(this)}
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+data class DirectiveArg(val str: String?, val name: String?, val int: Int?, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+}
+
+data class Label(val name: String, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Label(name=$name, pos=$position)"
+    }
+
+    val scopedname: String by lazy { makeScopedName(name) }
+}
+
+open class Return(var value: Expression?, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = value!=null && value !is NumericLiteralValue
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        value?.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Return($value, pos=$position)"
+    }
+}
+
+class ReturnFromIrq(override val position: Position) : Return(null, position) {
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "ReturnFromIrq(pos=$position)"
+    }
+}
+
+class Continue(override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class Break(override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+
+enum class ZeropageWish {
+    REQUIRE_ZEROPAGE,
+    PREFER_ZEROPAGE,
+    DONTCARE,
+    NOT_IN_ZEROPAGE
+}
+
+class VarDecl(val type: VarDeclType,
+              private val declaredDatatype: DataType,
+              val zeropage: ZeropageWish,
+              var arraysize: ArrayIndex?,
+              val name: String,
+              private val structName: String?,
+              var value: Expression?,
+              val isArray: Boolean,
+              val autogeneratedDontRemove: Boolean,
+              override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    var struct: StructDecl? = null        // set later (because at parse time, we only know the name)
+        private set
+    var structHasBeenFlattened = false      // set later
+        private set
+
+    override val expensiveToInline
+            get() = value!=null && value !is NumericLiteralValue
+
+    // prefix for literal values that are turned into a variable on the heap
+
+    companion object {
+        private var autoHeapValueSequenceNumber = 0
+
+        fun createAuto(refLv: ReferenceLiteralValue, heap: HeapValues): VarDecl {
+            if(refLv.heapId==null)
+                throw FatalAstException("can only create autovar for a ref lv that has a heapid  $refLv")
+
+            val autoVarName = "auto_heap_value_${++autoHeapValueSequenceNumber}"
+            return if(refLv.isArray) {
+                val declaredType = ArrayElementTypes.getValue(refLv.type)
+                val arraysize = ArrayIndex.forArray(refLv, heap)
+                VarDecl(VarDeclType.VAR, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, null, refLv,
+                        isArray = true, autogeneratedDontRemove = true, position = refLv.position)
+            } else {
+                VarDecl(VarDeclType.VAR, refLv.type, ZeropageWish.NOT_IN_ZEROPAGE, null, autoVarName, null, refLv,
+                        isArray = false, autogeneratedDontRemove = true, position = refLv.position)
+            }
+        }
+    }
+
+    val datatypeErrors = mutableListOf<SyntaxError>()       // don't crash at init time, report them in the AstChecker
+    val datatype =
+            if (!isArray) declaredDatatype
+            else when (declaredDatatype) {
+                DataType.UBYTE -> DataType.ARRAY_UB
+                DataType.BYTE -> DataType.ARRAY_B
+                DataType.UWORD -> DataType.ARRAY_UW
+                DataType.WORD -> DataType.ARRAY_W
+                DataType.FLOAT -> DataType.ARRAY_F
+                else -> {
+                    datatypeErrors.add(SyntaxError("array can only contain bytes/words/floats", position))
+                    DataType.ARRAY_UB
+                }
+            }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        arraysize?.linkParents(this)
+        value?.linkParents(this)
+        if(structName!=null) {
+            val structStmt = definingScope().lookup(listOf(structName), this)
+            if(structStmt!=null)
+                struct = definingScope().lookup(listOf(structName), this) as StructDecl
+        }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    val scopedname: String by lazy { makeScopedName(name) }
+
+    override fun toString(): String {
+        return "VarDecl(name=$name, vartype=$type, datatype=$datatype, struct=$structName, value=$value, pos=$position)"
+    }
+
+    fun asDefaultValueDecl(parent: Node?): VarDecl {
+        val constValue = when(declaredDatatype) {
+            DataType.UBYTE -> NumericLiteralValue(DataType.UBYTE, 0,  position)
+            DataType.BYTE -> NumericLiteralValue(DataType.BYTE, 0,  position)
+            DataType.UWORD -> NumericLiteralValue(DataType.UWORD, 0, position)
+            DataType.WORD -> NumericLiteralValue(DataType.WORD, 0, position)
+            DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, 0.0, position)
+            else -> throw FatalAstException("can only set a default value for a numeric type")
+        }
+        val decl = VarDecl(type, declaredDatatype, zeropage, arraysize, name, structName, constValue, isArray, false, position)
+        if(parent!=null)
+            decl.linkParents(parent)
+        return decl
+    }
+
+    fun flattenStructMembers(): MutableList<Statement> {
+        val result = struct!!.statements.withIndex().map {
+            val member = it.value as VarDecl
+            val initvalue = if(value!=null) (value as StructLiteralValue).values[it.index] else null
+            VarDecl(
+                    VarDeclType.VAR,
+                    member.datatype,
+                    ZeropageWish.NOT_IN_ZEROPAGE,
+                    member.arraysize,
+                    mangledStructMemberName(name, member.name),
+                    struct!!.name,
+                    initvalue,
+                    member.isArray,
+                    true,
+                    member.position
+            ) as Statement
+        }.toMutableList()
+        structHasBeenFlattened = true
+        return result
+    }
+
+    fun withPrefixedName(nameprefix: String): Statement {
+        val new = VarDecl(type, declaredDatatype, zeropage, arraysize, nameprefix+name, structName, value, isArray, autogeneratedDontRemove, position)
+        new.parent = parent
+        return new
+    }
+}
+
+class ArrayIndex(var index: Expression, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        index.linkParents(this)
+    }
+
+    companion object {
+        fun forArray(v: ReferenceLiteralValue, heap: HeapValues): ArrayIndex {
+            val arraySize = v.array?.size ?: heap.get(v.heapId!!).arraysize
+            return ArrayIndex(NumericLiteralValue.optimalNumeric(arraySize, v.position), v.position)
+        }
+    }
+
+    fun accept(visitor: IAstModifyingVisitor) {
+        index = index.accept(visitor)
+    }
+
+    fun accept(visitor: IAstVisitor) {
+        index.accept(visitor)
+    }
+
+    override fun toString(): String {
+        return("ArrayIndex($index, pos=$position)")
+    }
+
+    fun size() = (index as? NumericLiteralValue)?.number?.toInt()
+}
+
+open class Assignment(var target: AssignTarget, val aug_op : String?, var value: Expression, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline
+            get() = value !is NumericLiteralValue
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.target.linkParents(this)
+        value.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return("Assignment(augop: $aug_op, target: $target, value: $value, pos=$position)")
+    }
+}
+
+// This is a special class so the compiler can see if the assignments are for initializing the vars in the scope,
+// or just a regular assignment. It may optimize the initialization step from this.
+class VariableInitializationAssignment(target: AssignTarget, aug_op: String?, value: Expression, position: Position)
+    : Assignment(target, aug_op, value, position)
+
+data class AssignTarget(val register: Register?,
+                        var identifier: IdentifierReference?,
+                        var arrayindexed: ArrayIndexedExpression?,
+                        val memoryAddress: DirectMemoryWrite?,
+                        override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier?.linkParents(this)
+        arrayindexed?.linkParents(this)
+        memoryAddress?.linkParents(this)
+    }
+
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    companion object {
+        fun fromExpr(expr: Expression): AssignTarget {
+            return when (expr) {
+                is RegisterExpr -> AssignTarget(expr.register, null, null, null, expr.position)
+                is IdentifierReference -> AssignTarget(null, expr, null, null, expr.position)
+                is ArrayIndexedExpression -> AssignTarget(null, null, expr, null, expr.position)
+                is DirectMemoryRead -> AssignTarget(null, null, null, DirectMemoryWrite(expr.addressExpression, expr.position), expr.position)
+                else -> throw FatalAstException("invalid expression object $expr")
+            }
+        }
+    }
+
+    fun inferType(program: Program, stmt: Statement): DataType? {
+        if(register!=null)
+            return DataType.UBYTE
+
+        if(identifier!=null) {
+            val symbol = program.namespace.lookup(identifier!!.nameInSource, stmt) ?: return null
+            if (symbol is VarDecl) return symbol.datatype
+        }
+
+        if(arrayindexed!=null) {
+            val dt = arrayindexed!!.inferType(program)
+            if(dt!=null)
+                return dt
+        }
+
+        if(memoryAddress!=null)
+            return DataType.UBYTE
+
+        return null
+    }
+
+    infix fun isSameAs(value: Expression): Boolean {
+        return when {
+            this.memoryAddress!=null -> false
+            this.register!=null -> value is RegisterExpr && value.register==register
+            this.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier!!.nameInSource
+            this.arrayindexed!=null -> value is ArrayIndexedExpression &&
+                    value.identifier.nameInSource==arrayindexed!!.identifier.nameInSource &&
+                    value.arrayspec.size()!=null &&
+                    arrayindexed!!.arrayspec.size()!=null &&
+                    value.arrayspec.size()==arrayindexed!!.arrayspec.size()
+            else -> false
+        }
+    }
+
+    fun isSameAs(other: AssignTarget, program: Program): Boolean {
+        if(this===other)
+            return true
+        if(this.register!=null && other.register!=null)
+            return this.register==other.register
+        if(this.identifier!=null && other.identifier!=null)
+            return this.identifier!!.nameInSource==other.identifier!!.nameInSource
+        if(this.memoryAddress!=null && other.memoryAddress!=null) {
+            val addr1 = this.memoryAddress.addressExpression.constValue(program)
+            val addr2 = other.memoryAddress.addressExpression.constValue(program)
+            return addr1!=null && addr2!=null && addr1==addr2
+        }
+        if(this.arrayindexed!=null && other.arrayindexed!=null) {
+            if(this.arrayindexed!!.identifier.nameInSource == other.arrayindexed!!.identifier.nameInSource) {
+                val x1 = this.arrayindexed!!.arrayspec.index.constValue(program)
+                val x2 = other.arrayindexed!!.arrayspec.index.constValue(program)
+                return x1!=null && x2!=null && x1==x2
+            }
+        }
+        return false
+    }
+
+    fun isNotMemory(namespace: INameScope): Boolean {
+        if(this.register!=null)
+            return true
+        if(this.memoryAddress!=null)
+            return false
+        if(this.arrayindexed!=null) {
+            val targetStmt = this.arrayindexed!!.identifier.targetVarDecl(namespace)
+            if(targetStmt!=null)
+                return targetStmt.type!= VarDeclType.MEMORY
+        }
+        if(this.identifier!=null) {
+            val targetStmt = this.identifier!!.targetVarDecl(namespace)
+            if(targetStmt!=null)
+                return targetStmt.type!= VarDeclType.MEMORY
+        }
+        return false
+    }
+}
+
+class PostIncrDecr(var target: AssignTarget, val operator: String, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "PostIncrDecr(op: $operator, target: $target, pos=$position)"
+    }
+}
+
+class Jump(val address: Int?,
+           val identifier: IdentifierReference?,
+           val generatedLabel: String?,             // used in code generation scenarios
+           override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier?.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Jump(addr: $address, identifier: $identifier, label: $generatedLabel;  pos=$position)"
+    }
+}
+
+class FunctionCallStatement(override var target: IdentifierReference,
+                            override var arglist: MutableList<Expression>,
+                            override val position: Position) : Statement(), IFunctionCall {
+    override lateinit var parent: Node
+    override val expensiveToInline
+            get() = arglist.any { it !is NumericLiteralValue }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+        arglist.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "FunctionCallStatement(target=$target, pos=$position)"
+    }
+}
+
+class InlineAssembly(val assembly: String, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class AnonymousScope(override var statements: MutableList<Statement>,
+                     override val position: Position) : INameScope, Statement() {
+    override val name: String
+    override lateinit var parent: Node
+    override val expensiveToInline
+        get() = statements.any { it.expensiveToInline }
+
+    companion object {
+        private var sequenceNumber = 1
+    }
+
+    init {
+        name = "<anon-$sequenceNumber>"     // make sure it's an invalid soruce code identifier so user source code can never produce it
+        sequenceNumber++
+    }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class NopStatement(override val position: Position): Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    companion object {
+        fun insteadOf(stmt: Statement): NopStatement {
+            val nop = NopStatement(stmt.position)
+            nop.parent = stmt.parent
+            return nop
+        }
+    }
+}
+
+// the subroutine class covers both the normal user-defined subroutines,
+// and also the predefined/ROM/register-based subroutines.
+// (multiple return types can only occur for the latter type)
+class Subroutine(override val name: String,
+                 val parameters: List<SubroutineParameter>,
+                 val returntypes: List<DataType>,
+                 val asmParameterRegisters: List<RegisterOrStatusflag>,
+                 val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
+                 val asmClobbers: Set<Register>,
+                 val asmAddress: Int?,
+                 val isAsmSubroutine: Boolean,
+                 override var statements: MutableList<Statement>,
+                 override val position: Position) : Statement(), INameScope {
+
+    var keepAlways: Boolean = false
+    override val expensiveToInline
+            get() = statements.any { it.expensiveToInline }
+
+    override lateinit var parent: Node
+    val calledBy = mutableListOf<Node>()
+    val calls = mutableSetOf<Subroutine>()
+
+    val scopedname: String by lazy { makeScopedName(name) }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        parameters.forEach { it.linkParents(this) }
+        statements.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Subroutine(name=$name, parameters=$parameters, returntypes=$returntypes, ${statements.size} statements, address=$asmAddress)"
+    }
+
+    fun amountOfRtsInAsm(): Int = statements
+            .asSequence()
+            .filter { it is InlineAssembly }
+            .map { (it as InlineAssembly).assembly }
+            .count { " rti" in it || "\trti" in it || " rts" in it || "\trts" in it || " jmp" in it || "\tjmp" in it }
+
+    val canBeAsmSubroutine =false // TODO disabled for now, see below about problem with converting to asm subroutine
+//            !isAsmSubroutine
+//                    && ((parameters.size == 1 && parameters[0].type in setOf(DataType.BYTE, DataType.UBYTE, DataType.WORD, DataType.UWORD))
+//                    || (parameters.size == 2 && parameters.map { it.type }.all { it == DataType.BYTE || it == DataType.UBYTE }))
+
+    fun intoAsmSubroutine(): Subroutine {
+        // TODO turn subroutine into asm calling convention.   Requires rethinking of how parameters are handled (conflicts with local vardefs now, see AstIdentifierChecker...)
+        return this // TODO
+
+//        println("TO ASM   $this")  // TODO
+//        val paramregs = if (parameters.size == 1 && parameters[0].type in setOf(DataType.BYTE, DataType.UBYTE))
+//            listOf(RegisterOrStatusflag(RegisterOrPair.Y, null, null))
+//        else if (parameters.size == 1 && parameters[0].type in setOf(DataType.WORD, DataType.UWORD))
+//            listOf(RegisterOrStatusflag(RegisterOrPair.AY, null, null))
+//        else if (parameters.size == 2 && parameters.map { it.type }.all { it == DataType.BYTE || it == DataType.UBYTE })
+//            listOf(RegisterOrStatusflag(RegisterOrPair.A, null, null), RegisterOrStatusflag(RegisterOrPair.Y, null, null))
+//        else throw FatalAstException("cannot convert subroutine to asm parameters")
+//
+//        val asmsub=Subroutine(
+//                name,
+//                parameters,
+//                returntypes,
+//                paramregs,
+//                emptyList(),
+//                emptySet(),
+//                null,
+//                true,
+//                statements,
+//                position
+//        )
+//        asmsub.linkParents(parent)
+//        return asmsub
+    }
+}
+
+open class SubroutineParameter(val name: String,
+                               val type: DataType,
+                               override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+}
+
+class IfStatement(var condition: Expression,
+                  var truepart: AnonymousScope,
+                  var elsepart: AnonymousScope,
+                  override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean
+        get() = truepart.expensiveToInline || elsepart.expensiveToInline
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        truepart.linkParents(this)
+        elsepart.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class BranchStatement(var condition: BranchCondition,
+                      var truepart: AnonymousScope,
+                      var elsepart: AnonymousScope,
+                      override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean
+        get() = truepart.expensiveToInline || elsepart.expensiveToInline
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        truepart.linkParents(this)
+        elsepart.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class ForLoop(val loopRegister: Register?,
+              val decltype: DataType?,
+              val zeropage: ZeropageWish,
+              var loopVar: IdentifierReference?,
+              var iterable: Expression,
+              var body: AnonymousScope,
+              override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+        loopVar?.linkParents(if(decltype==null) this else body)
+        iterable.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "ForLoop(loopVar: $loopVar, loopReg: $loopRegister, iterable: $iterable, pos=$position)"
+    }
+}
+
+class WhileLoop(var condition: Expression,
+                var body: AnonymousScope,
+                override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class RepeatLoop(var body: AnonymousScope,
+                 var untilCondition: Expression,
+                 override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        untilCondition.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class WhenStatement(var condition: Expression,
+                    var choices: MutableList<WhenChoice>,
+                    override val position: Position): Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        choices.forEach { it.linkParents(this) }
+    }
+
+    fun choiceValues(program: Program): List<Pair<List<Int>?, WhenChoice>> {
+        // only gives sensible results when the choices are all valid (constant integers)
+        val result = mutableListOf<Pair<List<Int>?, WhenChoice>>()
+        for(choice in choices) {
+            if(choice.values==null)
+                result.add(null to choice)
+            else {
+                val values = choice.values!!.map { it.constValue(program)?.number?.toInt() }
+                if(values.contains(null))
+                    result.add(null to choice)
+                else
+                    result.add(values.filterNotNull() to choice)
+            }
+        }
+        return result
+    }
+
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+
+class WhenChoice(var values: List<Expression>?,           // if null,  this is the 'else' part
+                 var statements: AnonymousScope,
+                 override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        values?.forEach { it.linkParents(this) }
+        statements.linkParents(this)
+        this.parent = parent
+    }
+
+    override fun toString(): String {
+        return "Choice($values at $position)"
+    }
+
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+
+
+class StructDecl(override val name: String,
+                 override var statements: MutableList<Statement>,      // actually, only vardecls here
+                 override val position: Position): Statement(), INameScope {
+
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.statements.forEach { it.linkParents(this) }
+    }
+
+    val numberOfElements: Int
+        get() = this.statements.size
+
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+
+    fun nameOfFirstMember() = (statements.first() as VarDecl).name
+}
+
+class DirectMemoryWrite(var addressExpression: Expression, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.addressExpression.linkParents(this)
+    }
+
+    override fun toString(): String {
+        return "DirectMemoryWrite($addressExpression)"
+    }
+
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+

compiler/src/prog8/compiler/Main.kt

@@ -0,0 +1,177 @@
+package prog8.compiler
+
+import prog8.ast.AstToSourceCode
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.statements.Directive
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.codegen2.AsmGen2
+import prog8.optimizer.constantFold
+import prog8.optimizer.optimizeStatements
+import prog8.optimizer.simplifyExpressions
+import prog8.parser.ParsingFailedError
+import prog8.parser.importLibraryModule
+import prog8.parser.importModule
+import prog8.parser.moduleName
+import java.nio.file.Path
+import kotlin.system.measureTimeMillis
+
+
+class CompilationResult(val success: Boolean,
+                        val programAst: Program,
+                        val programName: String,
+                        val importedFiles: List<Path>)
+
+
+fun compileProgram(filepath: Path,
+                   optimize: Boolean, optimizeInlining: Boolean,
+                   writeAssembly: Boolean): CompilationResult {
+    lateinit var programAst: Program
+    var programName: String? = null
+
+    var importedFiles: List<Path> = emptyList()
+    var success=false
+
+    try {
+        val totalTime = measureTimeMillis {
+            // import main module and everything it needs
+            println("Parsing...")
+            programAst = Program(moduleName(filepath.fileName), mutableListOf())
+            importModule(programAst, filepath)
+
+            importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map{ it.source }
+
+            val compilerOptions = determineCompilationOptions(programAst)
+            if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
+                throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
+
+            // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
+            if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) {
+                importLibraryModule(programAst, "c64lib")
+                importLibraryModule(programAst, "c64utils")
+            }
+
+            // always import prog8lib and math
+            importLibraryModule(programAst, "math")
+            importLibraryModule(programAst, "prog8lib")
+
+
+            // perform initial syntax checks and constant folding
+            println("Syntax check...")
+            val time1 = measureTimeMillis {
+                programAst.checkIdentifiers()
+            }
+
+            //println(" time1: $time1")
+            val time2 = measureTimeMillis {
+                programAst.constantFold()
+            }
+            //println(" time2: $time2")
+            val time3 = measureTimeMillis {
+                programAst.removeNopsFlattenAnonScopes()
+                programAst.reorderStatements()     // reorder statements and add type casts, to please the compiler later
+            }
+            //println(" time3: $time3")
+            val time4 = measureTimeMillis {
+                programAst.checkValid(compilerOptions)          // check if tree is valid
+            }
+            //println(" time4: $time4")
+
+            programAst.checkIdentifiers()
+            if (optimize) {
+                // optimize the parse tree
+                println("Optimizing...")
+                while (true) {
+                    // keep optimizing expressions and statements until no more steps remain
+                    val optsDone1 = programAst.simplifyExpressions()
+                    val optsDone2 = programAst.optimizeStatements(optimizeInlining)
+                    if (optsDone1 + optsDone2 == 0)
+                        break
+                }
+            }
+
+            programAst.removeNopsFlattenAnonScopes()
+            programAst.checkValid(compilerOptions)          // check if final tree is valid
+            programAst.checkRecursion()         // check if there are recursive subroutine calls
+
+            printAst(programAst)
+
+            if(writeAssembly) {
+                // asm generation directly from the Ast, no need for intermediate code
+                val zeropage = MachineDefinition.C64Zeropage(compilerOptions)
+                programAst.anonscopeVarsCleanup()
+                val assembly = AsmGen2(programAst, compilerOptions, zeropage).compileToAssembly(optimize)
+                assembly.assemble(compilerOptions)
+                programName = assembly.name
+            }
+            success = true
+        }
+        println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
+
+    } catch (px: ParsingFailedError) {
+        System.err.print("\u001b[91m")  // bright red
+        System.err.println(px.message)
+        System.err.print("\u001b[0m")  // reset
+    } catch (ax: AstException) {
+        System.err.print("\u001b[91m")  // bright red
+        System.err.println(ax.toString())
+        System.err.print("\u001b[0m")  // reset
+    } catch (x: Exception) {
+        print("\u001b[91m")  // bright red
+        println("\n* internal error *")
+        print("\u001b[0m")  // reset
+        System.out.flush()
+        throw x
+    } catch (x: NotImplementedError) {
+        print("\u001b[91m")  // bright red
+        println("\n* internal error: missing feature/code *")
+        print("\u001b[0m")  // reset
+        System.out.flush()
+        throw x
+    }
+    return CompilationResult(success, programAst, programName ?: "", importedFiles)
+}
+
+fun printAst(programAst: Program) {
+    println()
+    val printer = AstToSourceCode(::print, programAst)
+    printer.visit(programAst)
+    println()
+}
+
+
+private fun determineCompilationOptions(program: Program): CompilationOptions {
+    val mainModule = program.modules.first()
+    val outputType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%output" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    val launcherType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%launcher" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    mainModule.loadAddress = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%address" }
+            as? Directive)?.args?.single()?.int ?: 0
+    val zpoption: String? = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%zeropage" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    val allOptions = program.modules.flatMap { it.statements }.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.toSet()
+    val floatsEnabled = allOptions.any { it.name == "enable_floats" }
+    val zpType: ZeropageType =
+            if (zpoption == null)
+                if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
+            else
+                try {
+                    ZeropageType.valueOf(zpoption)
+                } catch (x: IllegalArgumentException) {
+                    ZeropageType.KERNALSAFE
+                    // error will be printed by the astchecker
+                }
+    val zpReserved = mainModule.statements
+            .asSequence()
+            .filter { it is Directive && it.directive == "%zpreserved" }
+            .map { (it as Directive).args }
+            .map { it[0].int!!..it[1].int!! }
+            .toList()
+
+    return CompilationOptions(
+            if (outputType == null) OutputType.PRG else OutputType.valueOf(outputType),
+            if (launcherType == null) LauncherType.BASIC else LauncherType.valueOf(launcherType),
+            zpType, zpReserved, floatsEnabled
+    )
+}

compiler/src/prog8/compiler/Zeropage.kt

@@ -1,6 +1,6 @@
 package prog8.compiler
 
-import prog8.ast.*
+import prog8.ast.base.*
 
 
 class ZeropageDepletedError(message: String) : Exception(message)
@@ -16,7 +16,10 @@ abstract class Zeropage(protected val options: CompilationOptions) {
     fun available() = free.size
 
     fun allocate(scopedname: String, datatype: DataType, position: Position?): Int {
-        assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"same scopedname can't be allocated twice"}
+        assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"isSameAs scopedname can't be allocated twice"}
+
+        if(options.zeropage==ZeropageType.DONTUSE)
+            throw CompilerException("zero page usage has been disabled")
 
         val size =
                 when (datatype) {

compiler/src/prog8/compiler/intermediate/Value.kt

@@ -1,478 +0,0 @@
-package prog8.compiler.intermediate
-
-import prog8.ast.*
-import java.lang.Exception
-import kotlin.math.abs
-import kotlin.math.pow
-
-
-class ValueException(msg: String?) : Exception(msg)
-
-
-class Value(val type: DataType, numericvalueOrHeapId: Number) {
-    private var byteval: Short? = null
-    private var wordval: Int? = null
-    private var floatval: Double? = null
-    var heapId: Int = -1
-        private set
-    val asBooleanValue: Boolean
-
-    init {
-        when(type) {
-            DataType.UBYTE -> {
-                if(numericvalueOrHeapId.toInt() !in 0..255)
-                    throw ValueException("value out of range: $numericvalueOrHeapId")
-                byteval = numericvalueOrHeapId.toShort()
-                asBooleanValue = byteval != (0.toShort())
-            }
-            DataType.BYTE -> {
-                if(numericvalueOrHeapId.toInt() !in -128..127)
-                    throw ValueException("value out of range: $numericvalueOrHeapId")
-                byteval = numericvalueOrHeapId.toShort()
-                asBooleanValue = byteval != (0.toShort())
-            }
-            DataType.UWORD -> {
-                if(numericvalueOrHeapId.toInt() !in 0..65535)
-                    throw ValueException("value out of range: $numericvalueOrHeapId")
-                wordval = numericvalueOrHeapId.toInt()
-                asBooleanValue = wordval != 0
-            }
-            DataType.WORD -> {
-                if(numericvalueOrHeapId.toInt() !in -32768..32767)
-                    throw ValueException("value out of range: $numericvalueOrHeapId")
-                wordval = numericvalueOrHeapId.toInt()
-                asBooleanValue = wordval != 0
-            }
-            DataType.FLOAT -> {
-                floatval = numericvalueOrHeapId.toDouble()
-                asBooleanValue = floatval != 0.0
-            }
-            else -> {
-                if(numericvalueOrHeapId !is Int || numericvalueOrHeapId<0)
-                    throw ValueException("for non-numeric types, the value should be a integer heapId >= 0")
-                heapId = numericvalueOrHeapId
-                asBooleanValue=true
-            }
-        }
-    }
-
-    override fun toString(): String {
-        return when(type) {
-            DataType.UBYTE -> "ub:%02x".format(byteval)
-            DataType.BYTE -> {
-                if(byteval!!<0)
-                    "b:-%02x".format(abs(byteval!!.toInt()))
-                else
-                    "b:%02x".format(byteval)
-            }
-            DataType.UWORD -> "uw:%04x".format(wordval)
-            DataType.WORD -> {
-                if(wordval!!<0)
-                    "w:-%04x".format(abs(wordval!!))
-                else
-                    "w:%04x".format(wordval)
-            }
-            DataType.FLOAT -> "f:$floatval"
-            else -> "heap:$heapId"
-        }
-    }
-
-    fun numericValue(): Number {
-        return when(type) {
-            in ByteDatatypes -> byteval!!
-            in WordDatatypes -> wordval!!
-            DataType.FLOAT -> floatval!!
-            else -> throw ValueException("invalid datatype for numeric value: $type")
-        }
-    }
-
-    fun integerValue(): Int {
-        return when(type) {
-            in ByteDatatypes -> byteval!!.toInt()
-            in WordDatatypes -> wordval!!
-            DataType.FLOAT -> throw ValueException("float to integer loss of precision")
-            else -> throw ValueException("invalid datatype for integer value: $type")
-        }
-    }
-
-    override fun hashCode(): Int {
-        val bh = byteval?.hashCode() ?: 0x10001234
-        val wh = wordval?.hashCode() ?: 0x01002345
-        val fh = floatval?.hashCode() ?: 0x00103456
-        return bh xor wh xor fh xor heapId.hashCode() xor type.hashCode()
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if(other==null || other !is Value)
-            return false
-        if(type==other.type)
-            return if (type in IterableDatatypes) heapId==other.heapId else compareTo(other)==0
-        return compareTo(other)==0      // note: datatype doesn't matter
-    }
-
-    operator fun compareTo(other: Value): Int {
-        return if (type in NumericDatatypes && other.type in NumericDatatypes)
-                numericValue().toDouble().compareTo(other.numericValue().toDouble())
-            else throw ValueException("comparison can only be done between two numeric values")
-    }
-
-    private fun arithResult(leftDt: DataType, result: Number, rightDt: DataType, op: String): Value {
-        if(leftDt!=rightDt)
-            throw ValueException("left and right datatypes are not the same")
-        if(result.toDouble() < 0 ) {
-            return when(leftDt) {
-                DataType.UBYTE, DataType.UWORD -> {
-                    // storing a negative number in an unsigned one is done by storing the 2's complement instead
-                    val number = abs(result.toDouble().toInt())
-                    if(leftDt==DataType.UBYTE)
-                        Value(DataType.UBYTE, (number xor 255) + 1)
-                    else
-                        Value(DataType.UBYTE, (number xor 65535) + 1)
-                }
-                DataType.BYTE -> Value(DataType.BYTE, result.toInt())
-                DataType.WORD -> Value(DataType.WORD, result.toInt())
-                DataType.FLOAT -> Value(DataType.FLOAT, result)
-                else -> throw ValueException("$op on non-numeric type")
-            }
-        }
-
-        return when(leftDt) {
-            DataType.UBYTE -> Value(DataType.UBYTE, result.toInt() and 255)
-            DataType.BYTE -> Value(DataType.BYTE, result.toInt())
-            DataType.UWORD -> Value(DataType.UWORD, result.toInt() and 65535)
-            DataType.WORD -> Value(DataType.WORD, result.toInt())
-            DataType.FLOAT -> Value(DataType.FLOAT, result)
-            else -> throw ValueException("$op on non-numeric type")
-        }
-    }
-
-    fun add(other: Value): Value {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
-            throw ValueException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() + v2.toDouble()
-        return arithResult(type, result, other.type, "add")
-    }
-
-    fun sub(other: Value): Value {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
-            throw ValueException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() - v2.toDouble()
-        return arithResult(type, result, other.type, "sub")
-    }
-
-    fun mul(other: Value): Value {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
-            throw ValueException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() * v2.toDouble()
-        return arithResult(type, result, other.type, "mul")
-    }
-
-    fun div(other: Value): Value {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
-            throw ValueException("floating point loss of precision on type $type")
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        if(v2.toDouble()==0.0) {
-            when (type) {
-                DataType.UBYTE -> return Value(DataType.UBYTE, 255)
-                DataType.BYTE -> return Value(DataType.BYTE, 127)
-                DataType.UWORD -> return Value(DataType.UWORD, 65535)
-                DataType.WORD -> return Value(DataType.WORD, 32767)
-                else -> {}
-            }
-        }
-        val result = v1.toDouble() / v2.toDouble()
-        // NOTE: integer division returns integer result!
-        return when(type) {
-            DataType.UBYTE -> Value(DataType.UBYTE, result)
-            DataType.BYTE -> Value(DataType.BYTE, result)
-            DataType.UWORD -> Value(DataType.UWORD, result)
-            DataType.WORD -> Value(DataType.WORD, result)
-            DataType.FLOAT -> Value(DataType.FLOAT, result)
-            else -> throw ValueException("div on non-numeric type")
-        }
-    }
-
-    fun remainder(other: Value): Value? {
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble() % v2.toDouble()
-        return arithResult(type, result, other.type, "remainder")
-    }
-
-    fun pow(other: Value): Value {
-        val v1 = numericValue()
-        val v2 = other.numericValue()
-        val result = v1.toDouble().pow(v2.toDouble())
-        return arithResult(type, result, other.type,"pow")
-    }
-
-    fun shl(): Value {
-        val v = integerValue()
-        return when (type) {
-            DataType.UBYTE -> return Value(type, (v shl 1) and 255)
-            DataType.BYTE -> {
-                if(v<0)
-                    Value(type, -((-v shl 1) and 255))
-                else
-                    Value(type, (v shl 1) and 255)
-            }
-            DataType.UWORD -> return Value(type, (v shl 1) and 65535)
-            DataType.WORD -> {
-                if(v<0)
-                    Value(type, -((-v shl 1) and 65535))
-                else
-                    Value(type, (v shl 1) and 65535)
-            }
-            else -> throw ValueException("invalid type for shl: $type")
-        }
-    }
-
-    fun shr(): Value {
-        val v = integerValue()
-        return when(type){
-            DataType.UBYTE -> Value(type, (v ushr 1) and 255)
-            DataType.BYTE -> Value(type, v shr 1)
-            DataType.UWORD -> Value(type, (v ushr 1) and 65535)
-            DataType.WORD -> Value(type, v shr 1)
-            else -> throw ValueException("invalid type for shr: $type")
-        }
-    }
-
-    fun rol(carry: Boolean): Pair<Value, Boolean> {
-        // 9 or 17 bit rotate left (with carry))
-        return when(type) {
-            DataType.UBYTE -> {
-                val v = byteval!!.toInt()
-                val newCarry = (v and 0x80) != 0
-                val newval = (v and 0x7f shl 1) or (if(carry) 1 else 0)
-                Pair(Value(DataType.UBYTE, newval), newCarry)
-            }
-            DataType.UWORD -> {
-                val v = wordval!!
-                val newCarry = (v and 0x8000) != 0
-                val newval = (v and 0x7fff shl 1) or (if(carry) 1 else 0)
-                Pair(Value(DataType.UWORD, newval), newCarry)
-            }
-            else -> throw ValueException("rol can only work on byte/word")
-        }
-    }
-
-    fun ror(carry: Boolean): Pair<Value, Boolean> {
-        // 9 or 17 bit rotate right (with carry)
-        return when(type) {
-            DataType.UBYTE -> {
-                val v = byteval!!.toInt()
-                val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if(carry) 0x80 else 0)
-                Pair(Value(DataType.UBYTE, newval), newCarry)
-            }
-            DataType.UWORD -> {
-                val v = wordval!!
-                val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if(carry) 0x8000 else 0)
-                Pair(Value(DataType.UWORD, newval), newCarry)
-            }
-            else -> throw ValueException("ror2 can only work on byte/word")
-        }
-    }
-
-    fun rol2(): Value {
-        // 8 or 16 bit rotate left
-        return when(type) {
-            DataType.UBYTE -> {
-                val v = byteval!!.toInt()
-                val carry = (v and 0x80) ushr 7
-                val newval = (v and 0x7f shl 1) or carry
-                Value(DataType.UBYTE, newval)
-            }
-            DataType.UWORD -> {
-                val v = wordval!!
-                val carry = (v and 0x8000) ushr 15
-                val newval = (v and 0x7fff shl 1) or carry
-                Value(DataType.UWORD, newval)
-            }
-            else -> throw ValueException("rol2 can only work on byte/word")
-        }
-    }
-
-    fun ror2(): Value {
-        // 8 or 16 bit rotate right
-        return when(type) {
-            DataType.UBYTE -> {
-                val v = byteval!!.toInt()
-                val carry = v and 1 shl 7
-                val newval = (v ushr 1) or carry
-                Value(DataType.UBYTE, newval)
-            }
-            DataType.UWORD -> {
-                val v = wordval!!
-                val carry = v and 1 shl 15
-                val newval = (v ushr 1) or carry
-                Value(DataType.UWORD, newval)
-            }
-            else -> throw ValueException("ror2 can only work on byte/word")
-        }
-    }
-
-    fun neg(): Value {
-        return when(type) {
-            DataType.BYTE -> Value(DataType.BYTE, -(byteval!!))
-            DataType.WORD -> Value(DataType.WORD, -(wordval!!))
-            DataType.FLOAT -> Value(DataType.FLOAT, -(floatval)!!)
-            else -> throw ValueException("neg can only work on byte/word/float")
-        }
-    }
-
-    fun abs(): Value {
-        return when(type) {
-            DataType.BYTE -> Value(DataType.BYTE, abs(byteval!!.toInt()))
-            DataType.WORD -> Value(DataType.WORD, abs(wordval!!))
-            DataType.FLOAT -> Value(DataType.FLOAT, abs(floatval!!))
-            else -> throw ValueException("abs can only work on byte/word/float")
-        }
-    }
-
-    fun bitand(other: Value): Value {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 and v2
-        return Value(type, result)
-    }
-
-    fun bitor(other: Value): Value {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 or v2
-        return Value(type, result)
-    }
-
-    fun bitxor(other: Value): Value {
-        val v1 = integerValue()
-        val v2 = other.integerValue()
-        val result = v1 xor v2
-        return Value(type, result)
-    }
-
-    fun and(other: Value) = Value(DataType.UBYTE, if (this.asBooleanValue && other.asBooleanValue) 1 else 0)
-    fun or(other: Value) = Value(DataType.UBYTE, if (this.asBooleanValue || other.asBooleanValue) 1 else 0)
-    fun xor(other: Value) = Value(DataType.UBYTE, if (this.asBooleanValue xor other.asBooleanValue) 1 else 0)
-    fun not() = Value(DataType.UBYTE, if (this.asBooleanValue) 0 else 1)
-
-    fun inv(): Value {
-        return when(type) {
-            DataType.UBYTE -> Value(DataType.UBYTE, byteval!!.toInt().inv() and 255)
-            DataType.UWORD -> Value(DataType.UWORD, wordval!!.inv() and 65535)
-            else -> throw ValueException("inv can only work on byte/word")
-        }
-    }
-
-    fun inc(): Value {
-        return when(type) {
-            DataType.UBYTE -> Value(DataType.UBYTE, (byteval!! + 1) and 255)
-            DataType.UWORD -> Value(DataType.UWORD, (wordval!! + 1) and 65535)
-            DataType.FLOAT -> Value(DataType.FLOAT, floatval!! + 1)
-            else -> throw ValueException("inc can only work on byte/word/float")
-        }
-    }
-
-    fun dec(): Value {
-        return when(type) {
-            DataType.UBYTE -> Value(DataType.UBYTE, (byteval!! - 1) and 255)
-            DataType.UWORD -> Value(DataType.UWORD, (wordval!! - 1) and 65535)
-            DataType.FLOAT -> Value(DataType.FLOAT, floatval!! - 1)
-            else -> throw ValueException("dec can only work on byte/word/float")
-        }
-    }
-
-    fun msb(): Value {
-        return when(type) {
-            in ByteDatatypes -> Value(DataType.UBYTE, 0)
-            in WordDatatypes -> Value(DataType.UBYTE, wordval!! ushr 8 and 255)
-            else -> throw ValueException("msb can only work on (u)byte/(u)word")
-        }
-    }
-
-    fun cast(targetType: DataType): Value {
-        return when (type) {
-            DataType.UBYTE -> {
-                when (targetType) {
-                    DataType.UBYTE -> this
-                    DataType.BYTE -> {
-                        if(byteval!!<=127)
-                            Value(DataType.BYTE, byteval!!)
-                        else
-                            Value(DataType.BYTE, -(256-byteval!!))
-                    }
-                    DataType.UWORD -> Value(DataType.UWORD, numericValue())
-                    DataType.WORD -> Value(DataType.WORD, numericValue())
-                    DataType.FLOAT -> Value(DataType.FLOAT, numericValue())
-                    else -> throw ValueException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.BYTE -> {
-                when (targetType) {
-                    DataType.BYTE -> this
-                    DataType.UBYTE -> Value(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> Value(DataType.UWORD, integerValue() and 65535)
-                    DataType.WORD -> Value(DataType.WORD, integerValue())
-                    DataType.FLOAT -> Value(DataType.FLOAT, numericValue())
-                    else -> throw ValueException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.UWORD -> {
-                when (targetType) {
-                    in ByteDatatypes -> Value(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> this
-                    DataType.WORD -> {
-                        if(integerValue()<=32767)
-                            Value(DataType.WORD, integerValue())
-                        else
-                            Value(DataType.WORD, -(65536-integerValue()))
-                    }
-                    DataType.FLOAT -> Value(DataType.FLOAT, numericValue())
-                    else -> throw ValueException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.WORD -> {
-                when (targetType) {
-                    in ByteDatatypes -> Value(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> Value(DataType.UWORD, integerValue() and 65535)
-                    DataType.WORD -> this
-                    DataType.FLOAT -> Value(DataType.FLOAT, numericValue())
-                    else -> throw ValueException("invalid type cast from $type to $targetType")
-                }
-            }
-            DataType.FLOAT -> {
-                when (targetType) {
-                    DataType.BYTE -> {
-                        val integer=numericValue().toInt()
-                        if(integer in -128..127)
-                            Value(DataType.BYTE, integer)
-                        else
-                            throw ValueException("overflow when casting float to byte: $this")
-                    }
-                    DataType.UBYTE -> Value(DataType.UBYTE, numericValue().toInt() and 255)
-                    DataType.UWORD -> Value(DataType.UWORD, numericValue().toInt() and 65535)
-                    DataType.WORD -> {
-                        val integer=numericValue().toInt()
-                        if(integer in -32768..32767)
-                            Value(DataType.WORD, integer)
-                        else
-                            throw ValueException("overflow when casting float to word: $this")
-                    }
-                    DataType.FLOAT -> this
-                    else -> throw ValueException("invalid type cast from $type to $targetType")
-                }
-            }
-            else -> throw ValueException("invalid type cast from $type to $targetType")
-        }
-    }
-
-}

compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt

@@ -9,10 +9,25 @@ class AssemblyProgram(val name: String) {
     private val assemblyFile = "$name.asm"
     private val viceMonListFile = "$name.vice-mon-list"
 
+    companion object {
+        // 6502 opcodes (including aliases and illegal opcodes), these cannot be used as variable or label names
+        val opcodeNames = setOf("adc", "ahx", "alr", "anc", "and", "ane", "arr", "asl", "asr", "axs", "bcc", "bcs",
+                "beq", "bge", "bit", "blt", "bmi", "bne", "bpl", "brk", "bvc", "bvs", "clc",
+                "cld", "cli", "clv", "cmp", "cpx", "cpy", "dcm", "dcp", "dec", "dex", "dey",
+                "eor", "gcc", "gcs", "geq", "gge", "glt", "gmi", "gne", "gpl", "gvc", "gvs",
+                "inc", "ins", "inx", "iny", "isb", "isc", "jam", "jmp", "jsr", "lae", "las",
+                "lax", "lda", "lds", "ldx", "ldy", "lsr", "lxa", "nop", "ora", "pha", "php",
+                "pla", "plp", "rla", "rol", "ror", "rra", "rti", "rts", "sax", "sbc", "sbx",
+                "sec", "sed", "sei", "sha", "shl", "shr", "shs", "shx", "shy", "slo", "sre",
+                "sta", "stx", "sty", "tas", "tax", "tay", "tsx", "txa", "txs", "tya", "xaa")
+    }
+
+
     fun assemble(options: CompilationOptions) {
         // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps
-        val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch", "-Wall", "-Wno-strict-bool",
-                "-Werror", "-Wno-error=long-branch", "--dump-labels", "--vice-labels", "-l", viceMonListFile, "--no-monitor")
+        val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
+                "-Wall", "-Wno-strict-bool", "-Wno-shadow", "-Werror", "-Wno-error=long-branch",
+                "--dump-labels", "--vice-labels", "-l", viceMonListFile, "--no-monitor")
 
         val outFile = when(options.output) {
             OutputType.PRG -> {
@@ -41,7 +56,7 @@ class AssemblyProgram(val name: String) {
     private fun generateBreakpointList() {
         // builds list of breakpoints, appends to monitor list file
         val breakpoints = mutableListOf<String>()
-        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that's generated for them
+        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that"s generated for them
         for(line in File(viceMonListFile).readLines()) {
             val match = pattern.matchEntire(line)
             if(match!=null)

compiler/src/prog8/compiler/target/c64/Commodore64.kt

@@ -1,186 +0,0 @@
-package prog8.compiler.target.c64
-
-import prog8.compiler.CompilationOptions
-import prog8.compiler.CompilerException
-import prog8.compiler.Zeropage
-import prog8.compiler.ZeropageType
-import java.awt.Color
-import java.awt.image.BufferedImage
-import javax.imageio.ImageIO
-import kotlin.math.absoluteValue
-import kotlin.math.pow
-
-
-// 5-byte cbm MFLPT format limitations:
-const val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
-const val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
-
-const val BASIC_LOAD_ADDRESS = 0x0801
-const val RAW_LOAD_ADDRESS = 0xc000
-
-// the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-const val ESTACK_LO = 0xce00        //  $ce00-$ceff inclusive
-const val ESTACK_HI = 0xcf00        //  $cf00-$cfff inclusive
-
-
-class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
-
-    companion object {
-        const val SCRATCH_B1 = 0x02
-        const val SCRATCH_REG = 0x03    // temp storage for a register
-        const val SCRATCH_REG_X = 0xfa    // temp storage for register X (the evaluation stack pointer)
-        const val SCRATCH_W1 = 0xfb     // $fb+$fc
-        const val SCRATCH_W2 = 0xfd     // $fd+$fe
-    }
-
-    override val exitProgramStrategy: ExitProgramStrategy = when(options.zeropage) {
-        ZeropageType.BASICSAFE -> ExitProgramStrategy.CLEAN_EXIT
-        ZeropageType.FLOATSAFE, ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
-    }
-
-
-    init {
-        if(options.floats && options.zeropage!=ZeropageType.FLOATSAFE && options.zeropage!=ZeropageType.BASICSAFE)
-            throw CompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe'")
-
-        if(options.zeropage == ZeropageType.FULL) {
-            free.addAll(0x04 .. 0xf9)
-            free.add(0xff)
-            free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1+1, SCRATCH_W2, SCRATCH_W2+1))
-            free.removeAll(listOf(0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6))        // these are updated by IRQ
-        } else {
-            if(options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
-                free.addAll(listOf(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
-                        0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
-                        0x22, 0x23, 0x24, 0x25,
-                        0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
-                        0x47, 0x48, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53,
-                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
-                        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-                        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
-                        0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
-                        0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
-                        0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xff
-                        // 0x90-0xfa is 'kernel work storage area'
-                ))
-            }
-
-            if(options.zeropage == ZeropageType.FLOATSAFE) {
-                // remove the zero page locations used for floating point operations from the free list
-                free.removeAll(listOf(
-                        0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
-                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
-                        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-                        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
-                        0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xf
-                ))
-            }
-
-            // add the other free Zp addresses,
-            // these are valid for the C-64 (when no RS232 I/O is performed) but to keep BASIC running fully:
-            free.addAll(listOf(0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0d, 0x0e,
-                    0x94, 0x95, 0xa7, 0xa8, 0xa9, 0xaa,
-                    0xb5, 0xb6, 0xf7, 0xf8, 0xf9))
-        }
-        assert(SCRATCH_B1 !in free)
-        assert(SCRATCH_REG !in free)
-        assert(SCRATCH_REG_X !in free)
-        assert(SCRATCH_W1 !in free)
-        assert(SCRATCH_W2 !in free)
-
-        for(reserved in options.zpReserved)
-            reserve(reserved)
-    }
-}
-
-
-data class Mflpt5(val b0: Short, val b1: Short, val b2: Short, val b3: Short, val b4: Short) {
-
-    companion object {
-        const val MemorySize = 5
-
-        val zero = Mflpt5(0, 0,0,0,0)
-        fun fromNumber(num: Number): Mflpt5 {
-            // see https://en.wikipedia.org/wiki/Microsoft_Binary_Format
-            // and https://sourceforge.net/p/acme-crossass/code-0/62/tree/trunk/ACME_Lib/cbm/mflpt.a
-            // and https://en.wikipedia.org/wiki/IEEE_754-1985
-
-            val flt = num.toDouble()
-            if(flt < FLOAT_MAX_NEGATIVE || flt > FLOAT_MAX_POSITIVE)
-                throw CompilerException("floating point number out of 5-byte mflpt range: $this")
-            if(flt==0.0)
-                return zero
-
-            val sign = if(flt<0.0) 0x80L else 0x00L
-            var exponent = 128 + 32	// 128 is cbm's bias, 32 is this algo's bias
-            var mantissa = flt.absoluteValue
-
-            // if mantissa is too large, shift right and adjust exponent
-            while(mantissa >= 0x100000000) {
-                mantissa /= 2.0
-                exponent ++
-            }
-            // if mantissa is too small, shift left and adjust exponent
-            while(mantissa < 0x80000000) {
-                mantissa *= 2.0
-                exponent --
-            }
-
-            return when {
-                exponent<0 -> zero  // underflow, use zero instead
-                exponent>255 -> throw CompilerException("floating point overflow: $this")
-                exponent==0 -> zero
-                else -> {
-                    val mantLong = mantissa.toLong()
-                    Mflpt5(
-                            exponent.toShort(),
-                            (mantLong.and(0x7f000000L) ushr 24).or(sign).toShort(),
-                            (mantLong.and(0x00ff0000L) ushr 16).toShort(),
-                            (mantLong.and(0x0000ff00L) ushr 8).toShort(),
-                            (mantLong.and(0x000000ffL)).toShort())
-                }
-            }
-        }
-    }
-
-    fun toDouble(): Double {
-        if(this == zero) return 0.0
-        val exp = b0 - 128
-        val sign = (b1.toInt() and 0x80) > 0
-        val number = 0x80000000L.or(b1.toLong() shl 24).or(b2.toLong() shl 16).or(b3.toLong() shl 8).or(b4.toLong())
-        val result = number.toDouble() * (2.0).pow(exp) / 0x100000000
-        return if(sign) -result else result
-    }
-}
-
-object Charset {
-    private val normalImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-normal.png"))
-    private val shiftedImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-shifted.png"))
-
-    private fun scanChars(img: BufferedImage): Array<BufferedImage> {
-
-        val transparent = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
-        transparent.createGraphics().drawImage(img, 0, 0, null)
-
-        val black = Color(0,0,0).rgb
-        val nopixel = Color(0,0,0,0).rgb
-        for(y in 0 until transparent.height) {
-            for(x in 0 until transparent.width) {
-                val col = transparent.getRGB(x, y)
-                if(col==black)
-                    transparent.setRGB(x, y, nopixel)
-            }
-        }
-
-        val numColumns = transparent.width / 8
-        val charImages = (0..255).map {
-            val charX = it % numColumns
-            val charY = it/ numColumns
-            transparent.getSubimage(charX*8, charY*8, 8, 8)
-        }
-        return charImages.toTypedArray()
-    }
-
-    val normalChars = scanChars(normalImg)
-    val shiftedChars = scanChars(shiftedImg)
-}

compiler/src/prog8/compiler/target/c64/MachineDefinition.kt

@@ -0,0 +1,255 @@
+package prog8.compiler.target.c64
+
+import prog8.compiler.CompilationOptions
+import prog8.compiler.CompilerException
+import prog8.compiler.Zeropage
+import prog8.compiler.ZeropageType
+import java.awt.Color
+import java.awt.image.BufferedImage
+import javax.imageio.ImageIO
+import kotlin.math.absoluteValue
+import kotlin.math.pow
+
+object MachineDefinition {
+
+    // 5-byte cbm MFLPT format limitations:
+    const val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
+    const val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
+
+    const val BASIC_LOAD_ADDRESS = 0x0801
+    const val RAW_LOAD_ADDRESS = 0xc000
+
+    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
+    // and some heavily used string constants derived from the two values above
+    const val ESTACK_LO_VALUE       = 0xce00        //  $ce00-$ceff inclusive
+    const val ESTACK_HI_VALUE       = 0xcf00        //  $cf00-$cfff inclusive
+    const val ESTACK_LO_HEX         = "\$ce00"
+    const val ESTACK_LO_PLUS1_HEX   = "\$ce01"
+    const val ESTACK_LO_PLUS2_HEX   = "\$ce02"
+    const val ESTACK_HI_HEX         = "\$cf00"
+    const val ESTACK_HI_PLUS1_HEX   = "\$cf01"
+    const val ESTACK_HI_PLUS2_HEX   = "\$cf02"
+
+
+    class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
+
+        companion object {
+            const val SCRATCH_B1 = 0x02
+            const val SCRATCH_REG = 0x03    // temp storage for a register
+            const val SCRATCH_REG_X = 0xfa    // temp storage for register X (the evaluation stack pointer)
+            const val SCRATCH_W1 = 0xfb     // $fb+$fc
+            const val SCRATCH_W2 = 0xfd     // $fd+$fe
+        }
+
+        override val exitProgramStrategy: ExitProgramStrategy = when (options.zeropage) {
+            ZeropageType.BASICSAFE, ZeropageType.DONTUSE -> ExitProgramStrategy.CLEAN_EXIT
+            ZeropageType.FLOATSAFE, ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
+        }
+
+
+        init {
+            if (options.floats && options.zeropage !in setOf(ZeropageType.FLOATSAFE, ZeropageType.BASICSAFE, ZeropageType.DONTUSE ))
+                throw CompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe' or 'dontuse'")
+
+            if (options.zeropage == ZeropageType.FULL) {
+                free.addAll(0x04..0xf9)
+                free.add(0xff)
+                free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                free.removeAll(listOf(0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6))        // these are updated by IRQ
+            } else {
+                if (options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
+                    free.addAll(listOf(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
+                            0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
+                            0x22, 0x23, 0x24, 0x25,
+                            0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+                            0x47, 0x48, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53,
+                            0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
+                            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+                            0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
+                            0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
+                            0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+                            0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xff
+                            // 0x90-0xfa is 'kernel work storage area'
+                    ))
+                }
+
+                if (options.zeropage == ZeropageType.FLOATSAFE) {
+                    // remove the zero page locations used for floating point operations from the free list
+                    free.removeAll(listOf(
+                            0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
+                            0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
+                            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+                            0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
+                            0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xf
+                    ))
+                }
+
+                if(options.zeropage!=ZeropageType.DONTUSE) {
+                    // add the other free Zp addresses,
+                    // these are valid for the C-64 (when no RS232 I/O is performed) but to keep BASIC running fully:
+                    free.addAll(listOf(0x04, 0x05, 0x06, 0x0a, 0x0e,
+                            0x94, 0x95, 0xa7, 0xa8, 0xa9, 0xaa,
+                            0xb5, 0xb6, 0xf7, 0xf8, 0xf9))
+                } else {
+                    // don't use the zeropage at all
+                    free.clear()
+                }
+            }
+            assert(SCRATCH_B1 !in free)
+            assert(SCRATCH_REG !in free)
+            assert(SCRATCH_REG_X !in free)
+            assert(SCRATCH_W1 !in free)
+            assert(SCRATCH_W2 !in free)
+
+            for (reserved in options.zpReserved)
+                reserve(reserved)
+        }
+    }
+
+
+    data class Mflpt5(val b0: Short, val b1: Short, val b2: Short, val b3: Short, val b4: Short) {
+
+        companion object {
+            const val MemorySize = 5
+
+            val zero = Mflpt5(0, 0, 0, 0, 0)
+            fun fromNumber(num: Number): Mflpt5 {
+                // see https://en.wikipedia.org/wiki/Microsoft_Binary_Format
+                // and https://sourceforge.net/p/acme-crossass/code-0/62/tree/trunk/ACME_Lib/cbm/mflpt.a
+                // and https://en.wikipedia.org/wiki/IEEE_754-1985
+
+                val flt = num.toDouble()
+                if (flt < FLOAT_MAX_NEGATIVE || flt > FLOAT_MAX_POSITIVE)
+                    throw CompilerException("floating point number out of 5-byte mflpt range: $this")
+                if (flt == 0.0)
+                    return zero
+
+                val sign = if (flt < 0.0) 0x80L else 0x00L
+                var exponent = 128 + 32    // 128 is cbm's bias, 32 is this algo's bias
+                var mantissa = flt.absoluteValue
+
+                // if mantissa is too large, shift right and adjust exponent
+                while (mantissa >= 0x100000000) {
+                    mantissa /= 2.0
+                    exponent++
+                }
+                // if mantissa is too small, shift left and adjust exponent
+                while (mantissa < 0x80000000) {
+                    mantissa *= 2.0
+                    exponent--
+                }
+
+                return when {
+                    exponent < 0 -> zero  // underflow, use zero instead
+                    exponent > 255 -> throw CompilerException("floating point overflow: $this")
+                    exponent == 0 -> zero
+                    else -> {
+                        val mantLong = mantissa.toLong()
+                        Mflpt5(
+                                exponent.toShort(),
+                                (mantLong.and(0x7f000000L) ushr 24).or(sign).toShort(),
+                                (mantLong.and(0x00ff0000L) ushr 16).toShort(),
+                                (mantLong.and(0x0000ff00L) ushr 8).toShort(),
+                                (mantLong.and(0x000000ffL)).toShort())
+                    }
+                }
+            }
+        }
+
+        fun toDouble(): Double {
+            if (this == zero) return 0.0
+            val exp = b0 - 128
+            val sign = (b1.toInt() and 0x80) > 0
+            val number = 0x80000000L.or(b1.toLong() shl 24).or(b2.toLong() shl 16).or(b3.toLong() shl 8).or(b4.toLong())
+            val result = number.toDouble() * (2.0).pow(exp) / 0x100000000
+            return if (sign) -result else result
+        }
+    }
+
+    object Charset {
+        private val normalImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-normal.png"))
+        private val shiftedImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-shifted.png"))
+
+        private fun scanChars(img: BufferedImage): Array<BufferedImage> {
+
+            val transparent = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
+            transparent.createGraphics().drawImage(img, 0, 0, null)
+
+            val black = Color(0, 0, 0).rgb
+            val nopixel = Color(0, 0, 0, 0).rgb
+            for (y in 0 until transparent.height) {
+                for (x in 0 until transparent.width) {
+                    val col = transparent.getRGB(x, y)
+                    if (col == black)
+                        transparent.setRGB(x, y, nopixel)
+                }
+            }
+
+            val numColumns = transparent.width / 8
+            val charImages = (0..255).map {
+                val charX = it % numColumns
+                val charY = it / numColumns
+                transparent.getSubimage(charX * 8, charY * 8, 8, 8)
+            }
+            return charImages.toTypedArray()
+        }
+
+        val normalChars = scanChars(normalImg)
+        val shiftedChars = scanChars(shiftedImg)
+
+        private val coloredNormalChars = mutableMapOf<Short, Array<BufferedImage>>()
+
+        fun getColoredChar(screenCode: Short, color: Short): BufferedImage {
+            val colorIdx = (color % colorPalette.size).toShort()
+            val chars = coloredNormalChars[colorIdx]
+            if (chars != null)
+                return chars[screenCode.toInt()]
+
+            val coloredChars = mutableListOf<BufferedImage>()
+            val transparent = Color(0, 0, 0, 0).rgb
+            val rgb = colorPalette[colorIdx.toInt()].rgb
+            for (c in normalChars) {
+                val colored = c.copy()
+                for (y in 0 until colored.height)
+                    for (x in 0 until colored.width) {
+                        if (colored.getRGB(x, y) != transparent) {
+                            colored.setRGB(x, y, rgb)
+                        }
+                    }
+                coloredChars.add(colored)
+            }
+            coloredNormalChars[colorIdx] = coloredChars.toTypedArray()
+            return coloredNormalChars.getValue(colorIdx)[screenCode.toInt()]
+        }
+
+    }
+
+    private fun BufferedImage.copy(): BufferedImage {
+        val bcopy = BufferedImage(this.width, this.height, this.type)
+        val g = bcopy.graphics
+        g.drawImage(this, 0, 0, null)
+        g.dispose()
+        return bcopy
+    }
+
+
+    val colorPalette = listOf(         // this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
+            Color(0x000000),  // 0 = black
+            Color(0xFFFFFF),  // 1 = white
+            Color(0x813338),  // 2 = red
+            Color(0x75cec8),  // 3 = cyan
+            Color(0x8e3c97),  // 4 = purple
+            Color(0x56ac4d),  // 5 = green
+            Color(0x2e2c9b),  // 6 = blue
+            Color(0xedf171),  // 7 = yellow
+            Color(0x8e5029),  // 8 = orange
+            Color(0x553800),  // 9 = brown
+            Color(0xc46c71),  // 10 = light red
+            Color(0x4a4a4a),  // 11 = dark grey
+            Color(0x7b7b7b),  // 12 = medium grey
+            Color(0xa9ff9f),  // 13 = light green
+            Color(0x706deb),  // 14 = light blue
+            Color(0xb2b2b2)   // 15 = light grey
+    )
+
+}

compiler/src/prog8/compiler/target/c64/codegen2/AnonymousScopeVarsCleanup.kt

@@ -0,0 +1,48 @@
+package prog8.compiler.target.c64.codegen2
+
+import prog8.ast.Program
+import prog8.ast.base.AstException
+import prog8.ast.base.NameError
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.AnonymousScope
+import prog8.ast.statements.Statement
+import prog8.ast.statements.VarDecl
+
+class AnonymousScopeVarsCleanup(val program: Program): IAstModifyingVisitor {
+    private val checkResult: MutableList<AstException> = mutableListOf()
+    private val varsToMove: MutableMap<AnonymousScope, List<VarDecl>> = mutableMapOf()
+
+    fun result(): List<AstException> {
+        return checkResult
+    }
+
+    override fun visit(program: Program) {
+        varsToMove.clear()
+        super.visit(program)
+        for((scope, decls) in varsToMove) {
+            val sub = scope.definingSubroutine()!!
+            val existingVariables = sub.statements.filterIsInstance<VarDecl>().associate { it.name to it }
+            var conflicts = false
+            decls.forEach {
+                val existing = existingVariables[it.name]
+                if (existing!=null) {
+                    checkResult.add(NameError("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position))
+                    conflicts = true
+                }
+            }
+            if (!conflicts) {
+                decls.forEach { scope.remove(it) }
+                sub.statements.addAll(0, decls)
+                decls.forEach { it.parent = sub }
+            }
+        }
+    }
+
+    override fun visit(scope: AnonymousScope): Statement {
+        val scope2 = super.visit(scope) as AnonymousScope
+        val vardecls = scope2.statements.filterIsInstance<VarDecl>()
+        varsToMove[scope2] = vardecls
+        return scope2
+    }
+}
+

compiler/src/prog8/compiler/target/c64/codegen2/AsmOptimizer.kt

@@ -1,6 +1,11 @@
-package prog8.compiler.target.c64
+package prog8.compiler.target.c64.codegen2
+
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+
+
+// note: see https://wiki.nesdev.com/w/index.php/6502_assembly_optimisations
 
-import prog8.compiler.toHex
 
 fun optimizeAssembly(lines: MutableList<String>): Int {
 
@@ -24,10 +29,19 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
         numberOfOptimizations++
     }
 
+    removeLines = optimizeCmpSequence(linesByFour)
+    if(removeLines.isNotEmpty()) {
+        for (i in removeLines.reversed())
+            lines.removeAt(i)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
     removeLines = optimizeStoreLoadSame(linesByFour)
     if(removeLines.isNotEmpty()) {
         for (i in removeLines.reversed())
             lines.removeAt(i)
+        linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
@@ -36,6 +50,7 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
     if(removeLines.isNotEmpty()) {
         for (i in removeLines.reversed())
             lines.removeAt(i)
+        linesByFourteen = getLinesBy(lines, 14)
         numberOfOptimizations++
     }
 
@@ -44,16 +59,36 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
     return numberOfOptimizations
 }
 
+fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
+    // the when statement (on bytes) generates a sequence of:
+    //	 lda $ce01,x
+    //	 cmp #$20
+    //	 beq  check_prog8_s72choice_32
+    //	 lda $ce01,x
+    //	 cmp #$21
+    //	 beq  check_prog8_s73choice_33
+    // the repeated lda can be removed
+    val removeLines = mutableListOf<Int>()
+    for(lines in linesByFour) {
+        if(lines[0].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x" &&
+                lines[1].value.trim().startsWith("cmp ") &&
+                lines[2].value.trim().startsWith("beq ") &&
+                lines[3].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x") {
+            removeLines.add(lines[3].index) // remove the second lda
+        }
+    }
+    return removeLines
+}
+
 fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
     // sta on stack, dex, inx, lda from stack -> eliminate this useless stack byte write
     // this is a lot harder for word values because the instruction sequence varies.
     val removeLines = mutableListOf<Int>()
     for(lines in linesByFour) {
-        if(lines[0].value.trim()=="sta  ${ESTACK_LO.toHex()},x" &&
+        if(lines[0].value.trim()=="sta  $ESTACK_LO_HEX,x" &&
                 lines[1].value.trim()=="dex" &&
                 lines[2].value.trim()=="inx" &&
-                lines[3].value.trim()=="lda  ${ESTACK_LO.toHex()},x") {
-            removeLines.add(lines[0].index)
+                lines[3].value.trim()=="lda  $ESTACK_LO_HEX,x") {
             removeLines.add(lines[1].index)
             removeLines.add(lines[2].index)
             removeLines.add(lines[3].index)
@@ -64,7 +99,7 @@ fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>
 
 fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>): List<Int> {
 
-    // optimize sequential assignments of the same value to various targets (bytes, words, floats)
+    // optimize sequential assignments of the isSameAs value to various targets (bytes, words, floats)
     // the float one is the one that requires 2*7=14 lines of code to check...
     // @todo a better place to do this is in the Compiler instead and work on opcodes, and never even create the inefficient asm...
 
@@ -86,7 +121,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
             val thirdvalue = fifth.substring(4)
             val fourthvalue = sixth.substring(4)
             if(firstvalue==thirdvalue && secondvalue==fourthvalue) {
-                // lda/ldy   sta/sty   twice the same word -->  remove second lda/ldy pair (fifth and sixth lines)
+                // lda/ldy   sta/sty   twice the isSameAs word -->  remove second lda/ldy pair (fifth and sixth lines)
                 removeLines.add(pair[4].index)
                 removeLines.add(pair[5].index)
             }
@@ -96,7 +131,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
             val firstvalue = first.substring(4)
             val secondvalue = third.substring(4)
             if(firstvalue==secondvalue) {
-                // lda value / sta ? / lda same-value / sta ?  -> remove second lda (third line)
+                // lda value / sta ? / lda isSameAs-value / sta ?  -> remove second lda (third line)
                 removeLines.add(pair[2].index)
             }
         }
@@ -128,7 +163,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
 }
 
 private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
-// all lines (that aren't empty or comments) in sliding pairs of 2
+// all lines (that aren't empty or comments) in sliding windows of certain size
         lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
 
 private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Int> {

compiler/src/prog8/compiler/target/c64/codegen2/BuiltinFunctionsAsmGen.kt

@@ -0,0 +1,252 @@
+package prog8.compiler.target.c64.codegen2
+
+import prog8.ast.IFunctionCall
+import prog8.ast.Program
+import prog8.ast.base.ByteDatatypes
+import prog8.ast.base.DataType
+import prog8.ast.base.Register
+import prog8.ast.base.WordDatatypes
+import prog8.ast.expressions.*
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.FunctionCallStatement
+import prog8.compiler.CompilationOptions
+import prog8.compiler.Zeropage
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+import prog8.compiler.toHex
+import prog8.functions.FunctionSignature
+
+internal class BuiltinFunctionsAsmGen(private val program: Program,
+                                      private val options: CompilationOptions,
+                                      private val zeropage: Zeropage,
+                                      private val asmgen: AsmGen2) {
+
+    internal fun translateFunctioncallExpression(fcall: FunctionCall, func: FunctionSignature) {
+        translateFunctioncall(fcall, func, false)
+    }
+
+    internal fun translateFunctioncallStatement(fcall: FunctionCallStatement, func: FunctionSignature) {
+        translateFunctioncall(fcall, func, true)
+    }
+
+    private fun translateFunctioncall(fcall: IFunctionCall, func: FunctionSignature, discardResult: Boolean) {
+        val functionName = fcall.target.nameInSource.last()
+        if(discardResult) {
+            if(func.pure)
+                return  // can just ignore the whole function call altogether
+            else if(func.returntype!=null)
+                throw AssemblyError("discarding result of non-pure function $fcall")
+        }
+
+        when(functionName) {
+            "msb" -> {
+                val arg = fcall.arglist.single()
+                if(arg.inferType(program) !in WordDatatypes)
+                    throw AssemblyError("msb required word argument")
+                if(arg is NumericLiteralValue)
+                    throw AssemblyError("should have been const-folded")
+                if(arg is IdentifierReference) {
+                    val sourceName = asmgen.asmIdentifierName(arg)
+                    asmgen.out("  lda  $sourceName+1 |  sta  $ESTACK_LO_HEX,x |  dex")
+                } else {
+                    asmgen.translateExpression(arg)
+                    asmgen.out("  lda  $ESTACK_HI_PLUS1_HEX,x |  sta  $ESTACK_LO_PLUS1_HEX,x")
+                }
+            }
+            "mkword" -> {
+                translateFunctionArguments(fcall.arglist, func)
+                asmgen.out("  inx | lda  $ESTACK_LO_HEX,x  | sta  $ESTACK_HI_PLUS1_HEX,x")
+            }
+            "abs" -> {
+                translateFunctionArguments(fcall.arglist, func)
+                val dt = fcall.arglist.single().inferType(program)!!
+                when (dt) {
+                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.abs_b")
+                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.abs_w")
+                    DataType.FLOAT -> asmgen.out("  jsr  c64flt.abs_f")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "swap" -> {
+                val first = fcall.arglist[0]
+                val second = fcall.arglist[1]
+                asmgen.translateExpression(first)
+                asmgen.translateExpression(second)
+                // pop in reverse order
+                val firstTarget = AssignTarget.fromExpr(first)
+                val secondTarget = AssignTarget.fromExpr(second)
+                asmgen.assignFromEvalResult(firstTarget)
+                asmgen.assignFromEvalResult(secondTarget)
+            }
+            // TODO: any(f), all(f), max(f), min(f), sum(f)
+            "sin", "cos", "tan", "atan",
+            "ln", "log2", "sqrt", "rad",
+            "deg", "round", "floor", "ceil",
+            "rdnf" -> {
+                translateFunctionArguments(fcall.arglist, func)
+                asmgen.out("  jsr  c64flt.func_$functionName")
+            }
+/*
+        TODO this was the old code for bit rotations:
+            Opcode.SHL_BYTE -> AsmFragment(" asl  $variable+$index", 8)
+            Opcode.SHR_UBYTE -> AsmFragment(" lsr  $variable+$index", 8)
+            Opcode.SHR_SBYTE -> AsmFragment(" lda  $variable+$index |  asl  a |  ror  $variable+$index")
+            Opcode.SHL_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
+            Opcode.SHR_UWORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.SHR_SWORD -> AsmFragment(" lda  $variable+${index * 2 + 1} |  asl  a |  ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.ROL_BYTE -> AsmFragment(" rol  $variable+$index", 8)
+            Opcode.ROR_BYTE -> AsmFragment(" ror  $variable+$index", 8)
+            Opcode.ROL_WORD -> AsmFragment(" rol  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
+            Opcode.ROR_WORD -> AsmFragment(" ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
+            Opcode.ROL2_BYTE -> AsmFragment(" lda  $variable+$index |  cmp  #\$80 |  rol  $variable+$index", 8)
+            Opcode.ROR2_BYTE -> AsmFragment(" lda  $variable+$index |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $variable+$index", 10)
+            Opcode.ROL2_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2} |  bcc  + |  inc  $variable+${index * 2 + 1} |+", 20)
+            Opcode.ROR2_WORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2} |  bcc  + |  lda  $variable+${index * 2 + 1} |  ora  #\$80 |  sta  $variable+${index * 2 + 1} |+", 30)
+
+ */
+            "lsl" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    in ByteDatatypes -> {
+                        when(what) {
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  asl  a")
+                                    Register.X -> asmgen.out("  txa  |  asl  a |  tax")
+                                    Register.Y -> asmgen.out("  tya  |  asl  a |  tay")
+                                }
+                            }
+                            is IdentifierReference -> asmgen.out("  asl  ${asmgen.asmIdentifierName(what)}")
+                            is DirectMemoryRead -> {
+                                if(what.addressExpression is NumericLiteralValue) {
+                                    asmgen.out("  asl  ${(what.addressExpression as NumericLiteralValue).number.toHex()}")
+                                } else {
+                                    TODO("lsl memory byte $what")
+                                }
+                            }
+                            is ArrayIndexedExpression -> {
+                                TODO("lsl byte array $what")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    in WordDatatypes -> {
+                        TODO("lsl word $what")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "lsr" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    DataType.UBYTE -> {
+                        when(what) {
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  lsr  a")
+                                    Register.X -> asmgen.out("  txa  |  lsr  a |  tax")
+                                    Register.Y -> asmgen.out("  tya  |  lsr  a |  tay")
+                                }
+                            }
+                            is IdentifierReference -> asmgen.out("  lsr  ${asmgen.asmIdentifierName(what)}")
+                            is DirectMemoryRead -> {
+                                if(what.addressExpression is NumericLiteralValue) {
+                                    asmgen.out("  lsr  ${(what.addressExpression as NumericLiteralValue).number.toHex()}")
+                                } else {
+                                    TODO("lsr memory byte $what")
+                                }
+                            }
+                            is ArrayIndexedExpression -> {
+                                TODO("lsr byte array $what")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    DataType.BYTE -> {
+                        TODO("lsr sbyte $what")
+                    }
+                    DataType.UWORD -> {
+                        TODO("lsr sword $what")
+                    }
+                    DataType.WORD -> {
+                        TODO("lsr word $what")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "rol" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    DataType.UBYTE -> {
+                        TODO("rol ubyte")
+                    }
+                    DataType.UWORD -> {
+                        TODO("rol uword")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "rol2" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    DataType.UBYTE -> {
+                        TODO("rol2 ubyte")
+                    }
+                    DataType.UWORD -> {
+                        TODO("rol2 uword")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "ror" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    DataType.UBYTE -> {
+                        TODO("ror ubyte")
+                    }
+                    DataType.UWORD -> {
+                        TODO("ror uword")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "ror2" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)!!
+                when(dt) {
+                    DataType.UBYTE -> {
+                        TODO("ror2 ubyte")
+                    }
+                    DataType.UWORD -> {
+                        TODO("ror2 uword")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            else -> {
+                translateFunctionArguments(fcall.arglist, func)
+                asmgen.out("  jsr  prog8_lib.func_$functionName")
+            }
+        }
+    }
+
+    private fun translateFunctionArguments(args: MutableList<Expression>, signature: FunctionSignature) {
+        args.forEach {
+            asmgen.translateExpression(it)
+        }
+    }
+
+}
+

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -1,20 +1,22 @@
 package prog8.functions
 
-import prog8.ast.*
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
 import prog8.compiler.CompilerException
-import prog8.compiler.HeapValues
-import kotlin.math.PI
-import kotlin.math.cos
-import kotlin.math.log2
-import kotlin.math.sin
+import kotlin.math.*
 
 
 class BuiltinFunctionParam(val name: String, val possibleDatatypes: Set<DataType>)
 
+
+typealias ConstExpressionCaller = (args: List<Expression>, position: Position, program: Program) -> NumericLiteralValue
+
+
 class FunctionSignature(val pure: Boolean,      // does it have side effects?
                         val parameters: List<BuiltinFunctionParam>,
                         val returntype: DataType?,
-                        val constExpressionFunc: ((args: List<IExpression>, position: Position, namespace: INameScope, heap: HeapValues) -> LiteralValue)? = null)
+                        val constExpressionFunc: ConstExpressionCaller? = null)
 
 
 val BuiltinFunctions = mapOf(
@@ -26,38 +28,38 @@ val BuiltinFunctions = mapOf(
     "lsl"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
     "lsr"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
         // these few have a return value depending on the argument(s):
-    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.max()!! }},    // type depends on args
-    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.min()!! }},    // type depends on args
-    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.sum() }},      // type depends on args
+    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, _ -> collectionArgNeverConst(a, p) },    // type depends on args
+    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, _ -> collectionArgNeverConst(a, p) },    // type depends on args
+    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, _ -> collectionArgNeverConst(a, p) },      // type depends on args
     "abs"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
     "len"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
         // normal functions follow:
-    "sin"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::sin) },
+    "sin"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
     "sin8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
     "sin8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinSin8u ),
     "sin16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinSin16 ),
     "sin16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinSin16u ),
-    "cos"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::cos) },
+    "cos"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
     "cos8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinCos8 ),
     "cos8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinCos8u ),
     "cos16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinCos16 ),
     "cos16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinCos16u ),
-    "tan"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::tan) },
-    "atan"        to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::atan) },
-    "ln"          to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::log) },
-    "log2"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, ::log2) },
-    "sqrt16"      to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, n, h -> oneIntArgOutputInt(a, p, n, h) { Math.sqrt(it.toDouble()).toInt() } },
-    "sqrt"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::sqrt) },
-    "rad"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::toRadians) },
-    "deg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::toDegrees) },
-    "avg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.FLOAT, ::builtinAvg),
-    "round"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::round) },
-    "floor"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::floor) },
-    "ceil"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::ceil) },
-    "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, n, h -> collectionArgOutputBoolean(a, p, n, h) { it.any { v -> v != 0.0} }},
-    "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, n, h -> collectionArgOutputBoolean(a, p, n, h) { it.all { v -> v != 0.0} }},
-    "lsb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, n, h -> oneIntArgOutputInt(a, p, n, h) { x: Int -> x and 255 }},
-    "msb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, n, h -> oneIntArgOutputInt(a, p, n, h) { x: Int -> x ushr 8 and 255}},
+    "tan"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
+    "atan"        to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
+    "ln"          to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
+    "log2"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, ::log2) },
+    "sqrt16"      to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()).toInt() } },
+    "sqrt"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sqrt) },
+    "rad"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toRadians) },
+    "deg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toDegrees) },
+    "avg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.FLOAT) { a, p, _ -> collectionArgNeverConst(a, p) },
+    "round"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::round) },
+    "floor"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::floor) },
+    "ceil"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::ceil) },
+    "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, _ -> collectionArgNeverConst(a, p) },
+    "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, _ -> collectionArgNeverConst(a, p) },
+    "lsb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
+    "msb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x ushr 8 and 255}},
     "mkword"      to FunctionSignature(true, listOf(
                                                         BuiltinFunctionParam("lsb", setOf(DataType.UBYTE)),
                                                         BuiltinFunctionParam("msb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
@@ -111,30 +113,25 @@ val BuiltinFunctions = mapOf(
 )
 
 
-fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespace: INameScope, heap: HeapValues): DataType? {
+fun builtinFunctionReturnType(function: String, args: List<Expression>, program: Program): DataType? {
 
-    fun datatypeFromIterableArg(arglist: IExpression): DataType {
-        if(arglist is LiteralValue) {
-            if(arglist.type==DataType.ARRAY_UB || arglist.type==DataType.ARRAY_UW || arglist.type==DataType.ARRAY_F) {
-                val dt = arglist.arrayvalue!!.map {it.resultingDatatype(namespace, heap)}
-                if(dt.any { it!=DataType.UBYTE && it!=DataType.UWORD && it!=DataType.FLOAT}) {
+    fun datatypeFromIterableArg(arglist: Expression): DataType {
+        if(arglist is ReferenceLiteralValue) {
+            if(arglist.type== DataType.ARRAY_UB || arglist.type== DataType.ARRAY_UW || arglist.type== DataType.ARRAY_F) {
+                val dt = arglist.array!!.map {it.inferType(program)}
+                if(dt.any { it!= DataType.UBYTE && it!= DataType.UWORD && it!= DataType.FLOAT}) {
                     throw FatalAstException("fuction $function only accepts arraysize of numeric values")
                 }
-                if(dt.any { it==DataType.FLOAT }) return DataType.FLOAT
-                if(dt.any { it==DataType.UWORD }) return DataType.UWORD
+                if(dt.any { it== DataType.FLOAT }) return DataType.FLOAT
+                if(dt.any { it== DataType.UWORD }) return DataType.UWORD
                 return DataType.UBYTE
             }
         }
         if(arglist is IdentifierReference) {
-            val dt = arglist.resultingDatatype(namespace, heap)
-            return when(dt) {
+            return when(val dt = arglist.inferType(program)) {
                 in NumericDatatypes -> dt!!
                 in StringDatatypes -> dt!!
-                DataType.ARRAY_UB -> DataType.UBYTE
-                DataType.ARRAY_B -> DataType.BYTE
-                DataType.ARRAY_UW -> DataType.UWORD
-                DataType.ARRAY_W -> DataType.WORD
-                DataType.ARRAY_F -> DataType.FLOAT
+                in ArrayDatatypes -> ArrayElementTypes.getValue(dt!!)
                 else -> throw FatalAstException("function '$function' requires one argument which is an iterable")
             }
         }
@@ -148,30 +145,22 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespa
 
     return when (function) {
         "abs" -> {
-            val dt = args.single().resultingDatatype(namespace, heap)
-            when(dt) {
-                in ByteDatatypes -> DataType.UBYTE
-                in WordDatatypes -> DataType.UWORD
-                DataType.FLOAT -> DataType.FLOAT
-                else -> throw FatalAstException("weird datatype passed to abs $dt")
-            }
+            val dt = args.single().inferType(program)
+            if(dt in NumericDatatypes)
+                return dt
+            else
+                throw FatalAstException("weird datatype passed to abs $dt")
         }
         "max", "min" -> {
-            val dt = datatypeFromIterableArg(args.single())
-            when(dt) {
+            when(val dt = datatypeFromIterableArg(args.single())) {
                 in NumericDatatypes -> dt
                 in StringDatatypes -> DataType.UBYTE
-                DataType.ARRAY_UB -> DataType.UBYTE
-                DataType.ARRAY_B -> DataType.BYTE
-                DataType.ARRAY_UW -> DataType.UWORD
-                DataType.ARRAY_W -> DataType.WORD
-                DataType.ARRAY_F -> DataType.FLOAT
+                in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
                 else -> null
             }
         }
         "sum" -> {
-            val dt=datatypeFromIterableArg(args.single())
-            when(dt) {
+            when(datatypeFromIterableArg(args.single())) {
                 DataType.UBYTE, DataType.UWORD -> DataType.UWORD
                 DataType.BYTE, DataType.WORD -> DataType.WORD
                 DataType.FLOAT -> DataType.FLOAT
@@ -195,181 +184,98 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespa
 class NotConstArgumentException: AstException("not a const argument to a built-in function")
 
 
-private fun oneDoubleArg(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues, function: (arg: Double)->Number): LiteralValue {
+private fun oneDoubleArg(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Number): NumericLiteralValue {
     if(args.size!=1)
         throw SyntaxError("built-in function requires one floating point argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.FLOAT)
-        throw SyntaxError("built-in function requires one floating point argument", position)
-
-    val float = constval.asNumericValue?.toDouble()!!
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val float = constval.number.toDouble()
     return numericLiteral(function(float), args[0].position)
 }
 
-private fun oneDoubleArgOutputWord(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues, function: (arg: Double)->Number): LiteralValue {
+private fun oneDoubleArgOutputWord(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Number): NumericLiteralValue {
     if(args.size!=1)
         throw SyntaxError("built-in function requires one floating point argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.FLOAT)
-        throw SyntaxError("built-in function requires one floating point argument", position)
-    return LiteralValue(DataType.WORD, wordvalue=function(constval.asNumericValue!!.toDouble()).toInt(), position=args[0].position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val float = constval.number.toDouble()
+    return NumericLiteralValue(DataType.WORD, function(float).toInt(), args[0].position)
 }
 
-private fun oneIntArgOutputInt(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues, function: (arg: Int)->Number): LiteralValue {
+private fun oneIntArgOutputInt(args: List<Expression>, position: Position, program: Program, function: (arg: Int)->Number): NumericLiteralValue {
     if(args.size!=1)
         throw SyntaxError("built-in function requires one integer argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.UBYTE && constval.type!=DataType.UWORD)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    if(constval.type != DataType.UBYTE && constval.type!= DataType.UWORD)
         throw SyntaxError("built-in function requires one integer argument", position)
 
-    val integer = constval.asNumericValue?.toInt()!!
+    val integer = constval.number.toInt()
     return numericLiteral(function(integer).toInt(), args[0].position)
 }
 
-private fun collectionArgOutputNumber(args: List<IExpression>, position: Position,
-                                      namespace:INameScope, heap: HeapValues,
-                                      function: (arg: Collection<Double>)->Number): LiteralValue {
+private fun collectionArgNeverConst(args: List<Expression>, position: Position): NumericLiteralValue {
     if(args.size!=1)
         throw SyntaxError("builtin function requires one non-scalar argument", position)
-    val iterable = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
 
-    val result = if(iterable.arrayvalue != null) {
-        val constants = iterable.arrayvalue.map { it.constValue(namespace, heap)?.asNumericValue }
-        if(null in constants)
-            throw NotConstArgumentException()
-        function(constants.map { it!!.toDouble() }).toDouble()
-    } else {
-        when(iterable.type) {
-            DataType.UBYTE, DataType.UWORD, DataType.FLOAT -> throw SyntaxError("function expects an iterable type", position)
-            else -> {
-                if(iterable.heapId==null)
-                    throw FatalAstException("iterable value should be on the heap")
-                val array = heap.get(iterable.heapId).array ?: throw SyntaxError("function expects an iterable type", position)
-                function(array.map {
-                    if(it.integer!=null)
-                        it.integer.toDouble()
-                    else
-                        throw FatalAstException("cannot perform function over array that contains other values besides constant integers")
-                })
-            }
-        }
-    }
-    return numericLiteral(result, args[0].position)
+    // max/min/sum etc only work on arrays and these are never considered to be const for these functions
+    throw NotConstArgumentException()
 }
 
-private fun collectionArgOutputBoolean(args: List<IExpression>, position: Position,
-                                       namespace:INameScope, heap: HeapValues,
-                                       function: (arg: Collection<Double>)->Boolean): LiteralValue {
-    if(args.size!=1)
-        throw SyntaxError("builtin function requires one non-scalar argument", position)
-    val iterable = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-
-    val result = if(iterable.arrayvalue != null) {
-        val constants = iterable.arrayvalue.map { it.constValue(namespace, heap)?.asNumericValue }
-        if(null in constants)
-            throw NotConstArgumentException()
-        function(constants.map { it!!.toDouble() })
-    } else {
-        val array = heap.get(iterable.heapId!!).array ?: throw SyntaxError("function requires array argument", position)
-        function(array.map {
-            if(it.integer!=null)
-                it.integer.toDouble()
-            else
-                throw FatalAstException("cannot perform function over array that contains other values besides constant integers")
-        })
-    }
-    return LiteralValue.fromBoolean(result, position)
-}
-
-private fun builtinAbs(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
-    // 1 arg, type = float or int, result type= same as argument type
+private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
+    // 1 arg, type = float or int, result type= isSameAs as argument type
     if(args.size!=1)
         throw SyntaxError("abs requires one numeric argument", position)
 
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val number = constval.asNumericValue
-    return when (number) {
-        is Int, is Byte, is Short -> numericLiteral(Math.abs(number.toInt()), args[0].position)
-        is Double -> numericLiteral(Math.abs(number.toDouble()), args[0].position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    return when (constval.type) {
+        in IntegerDatatypes -> numericLiteral(abs(constval.number.toInt()), args[0].position)
+        DataType.FLOAT -> numericLiteral(abs(constval.number.toDouble()), args[0].position)
         else -> throw SyntaxError("abs requires one numeric argument", position)
     }
 }
 
-private fun builtinAvg(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
-    if(args.size!=1)
-        throw SyntaxError("avg requires array argument", position)
-    val iterable = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val result = if(iterable.arrayvalue!=null) {
-        val constants = iterable.arrayvalue.map { it.constValue(namespace, heap)?.asNumericValue }
-        if (null in constants)
-            throw NotConstArgumentException()
-        (constants.map { it!!.toDouble() }).average()
-    }
-    else {
-        val integerarray = heap.get(iterable.heapId!!).array
-        if(integerarray!=null) {
-            if (integerarray.all { it.integer != null }) {
-                integerarray.map { it.integer!! }.average()
-            } else {
-                throw ExpressionError("cannot avg() over array that does not only contain constant numerical values", position)
-            }
-        } else {
-            val doublearray = heap.get(iterable.heapId).doubleArray
-            doublearray?.average() ?: throw SyntaxError("avg requires array argument", position)
-        }
-    }
-    return numericLiteral(result, args[0].position)
-}
-
-private fun builtinStrlen(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinStrlen(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("strlen requires one argument", position)
-    val argument = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
+    val argument = args[0].constValue(program) ?: throw NotConstArgumentException()
     if(argument.type !in StringDatatypes)
         throw SyntaxError("strlen must have string argument", position)
-    val string = argument.strvalue(heap)
-    val zeroIdx = string.indexOf('\u0000')
-    return if(zeroIdx>=0)
-        LiteralValue.optimalInteger(zeroIdx, position=position)
-    else
-        LiteralValue.optimalInteger(string.length, position=position)
+
+    throw NotConstArgumentException()       // this function is not considering the string argument a constant
 }
 
-private fun builtinLen(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinLen(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     // note: in some cases the length is > 255 and then we have to return a UWORD type instead of a UBYTE.
     if(args.size!=1)
         throw SyntaxError("len requires one argument", position)
-    var argument = args[0].constValue(namespace, heap)
-    if(argument==null) {
-        val directMemVar = ((args[0] as? DirectMemoryRead)?.addressExpression as? IdentifierReference)?.targetVarDecl(namespace)
-        val arraySize = directMemVar?.arraysize?.size()
-        if(arraySize != null)
-            return LiteralValue.optimalInteger(arraySize, position)
-        if(args[0] !is IdentifierReference)
-            throw SyntaxError("len argument should be an identifier, but is ${args[0]}", position)
-        val target = (args[0] as IdentifierReference).targetStatement(namespace)
-        val argValue = (target as? VarDecl)?.value
-        argument = argValue?.constValue(namespace, heap)
-                ?: throw NotConstArgumentException()
-    }
-    return when(argument.type) {
+    val constArg = args[0].constValue(program)
+    if(constArg!=null)
+        throw SyntaxError("len of weird argument ${args[0]}", position)
+
+    val directMemVar = ((args[0] as? DirectMemoryRead)?.addressExpression as? IdentifierReference)?.targetVarDecl(program.namespace)
+    var arraySize = directMemVar?.arraysize?.size()
+    if(arraySize != null)
+        return NumericLiteralValue.optimalInteger(arraySize, position)
+    if(args[0] !is IdentifierReference)
+        throw SyntaxError("len argument should be an identifier, but is ${args[0]}", position)
+    val target = (args[0] as IdentifierReference).targetVarDecl(program.namespace)!!
+
+    return when(target.datatype) {
         DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-            val arraySize = argument.arrayvalue?.size ?: heap.get(argument.heapId!!).arraysize
+            arraySize = target.arraysize!!.size()!!
             if(arraySize>256)
-                throw CompilerException("array length exceeds byte limit ${argument.position}")
-            LiteralValue.optimalInteger(arraySize, args[0].position)
+                throw CompilerException("array length exceeds byte limit ${target.position}")
+            NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
         DataType.ARRAY_F -> {
-            val arraySize = argument.arrayvalue?.size ?: heap.get(argument.heapId!!).arraysize
+            arraySize = target.arraysize!!.size()!!
             if(arraySize>256)
-                throw CompilerException("array length exceeds byte limit ${argument.position}")
-            LiteralValue.optimalInteger(arraySize, args[0].position)
+                throw CompilerException("array length exceeds byte limit ${target.position}")
+            NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
         in StringDatatypes -> {
-            val str = argument.strvalue(heap)
-            if(str.length>255)
-                throw CompilerException("string length exceeds byte limit ${argument.position}")
-            LiteralValue.optimalInteger(str.length, args[0].position)
+            val refLv = target.value as ReferenceLiteralValue
+            if(refLv.str!!.length>255)
+                throw CompilerException("string length exceeds byte limit ${refLv.position}")
+            NumericLiteralValue.optimalInteger(refLv.str.length, args[0].position)
         }
         in NumericDatatypes -> throw SyntaxError("len of weird argument ${args[0]}", position)
         else -> throw CompilerException("weird datatype")
@@ -377,93 +283,93 @@ private fun builtinLen(args: List<IExpression>, position: Position, namespace:IN
 }
 
 
-private fun builtinMkword(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinMkword(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 2)
         throw SyntaxError("mkword requires lsb and msb arguments", position)
-    val constLsb = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val constMsb = args[1].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val result = (constMsb.asIntegerValue!! shl 8) or constLsb.asIntegerValue!!
-    return LiteralValue(DataType.UWORD, wordvalue = result, position = position)
+    val constLsb = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val constMsb = args[1].constValue(program) ?: throw NotConstArgumentException()
+    val result = (constMsb.number.toInt() shl 8) or constLsb.number.toInt()
+    return NumericLiteralValue(DataType.UWORD, result, position)
 }
 
-private fun builtinSin8(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinSin8(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("sin8 requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.BYTE, bytevalue = (127.0* sin(rad)).toShort(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.BYTE, (127.0 * sin(rad)).toShort(), position)
 }
 
-private fun builtinSin8u(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinSin8u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("sin8u requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UBYTE, bytevalue = (128.0+127.5*sin(rad)).toShort(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort(), position)
 }
 
-private fun builtinCos8(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinCos8(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("cos8 requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.BYTE, bytevalue = (127.0* cos(rad)).toShort(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.BYTE, (127.0 * cos(rad)).toShort(), position)
 }
 
-private fun builtinCos8u(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinCos8u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("cos8u requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UBYTE, bytevalue = (128.0 + 127.5*cos(rad)).toShort(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort(), position)
 }
 
-private fun builtinSin16(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinSin16(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("sin16 requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.WORD, wordvalue = (32767.0* sin(rad)).toInt(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.WORD, (32767.0 * sin(rad)).toInt(), position)
 }
 
-private fun builtinSin16u(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinSin16u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("sin16u requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UWORD, wordvalue = (32768.0+32767.5*sin(rad)).toInt(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.UWORD, (32768.0 + 32767.5 * sin(rad)).toInt(), position)
 }
 
-private fun builtinCos16(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinCos16(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("cos16 requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.WORD, wordvalue = (32767.0* cos(rad)).toInt(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.WORD, (32767.0 * cos(rad)).toInt(), position)
 }
 
-private fun builtinCos16u(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
+private fun builtinCos16u(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
     if (args.size != 1)
         throw SyntaxError("cos16u requires one argument", position)
-    val constval = args[0].constValue(namespace, heap) ?: throw NotConstArgumentException()
-    val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UWORD, wordvalue = (32768.0+32767.5* cos(rad)).toInt(), position = position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val rad = constval.number.toDouble() /256.0 * 2.0 * PI
+    return NumericLiteralValue(DataType.UWORD, (32768.0 + 32767.5 * cos(rad)).toInt(), position)
 }
 
-private fun numericLiteral(value: Number, position: Position): LiteralValue {
+private fun numericLiteral(value: Number, position: Position): NumericLiteralValue {
     val floatNum=value.toDouble()
     val tweakedValue: Number =
-            if(floatNum==Math.floor(floatNum) && (floatNum>=-32768 && floatNum<=65535))
+            if(floatNum== floor(floatNum) && (floatNum>=-32768 && floatNum<=65535))
                 floatNum.toInt()  // we have an integer disguised as a float.
             else
                 floatNum
 
     return when(tweakedValue) {
-        is Int -> LiteralValue.optimalNumeric(value.toInt(), position)
-        is Short -> LiteralValue.optimalNumeric(value.toInt(), position)
-        is Byte -> LiteralValue(DataType.UBYTE, bytevalue = value.toShort(), position = position)
-        is Double -> LiteralValue(DataType.FLOAT, floatvalue = value.toDouble(), position = position)
-        is Float -> LiteralValue(DataType.FLOAT, floatvalue = value.toDouble(), position = position)
+        is Int -> NumericLiteralValue.optimalNumeric(value.toInt(), position)
+        is Short -> NumericLiteralValue.optimalNumeric(value.toInt(), position)
+        is Byte -> NumericLiteralValue(DataType.UBYTE, value.toShort(), position)
+        is Double -> NumericLiteralValue(DataType.FLOAT, value.toDouble(), position)
+        is Float -> NumericLiteralValue(DataType.FLOAT, value.toDouble(), position)
         else -> throw FatalAstException("invalid number type ${value::class}")
     }
 }

compiler/src/prog8/optimizer/CallGraph.kt

@@ -0,0 +1,221 @@
+package prog8.optimizer
+
+import prog8.ast.INameScope
+import prog8.ast.Module
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.base.DataType
+import prog8.ast.base.ParentSentinel
+import prog8.ast.base.VarDeclType
+import prog8.ast.base.initvarsSubName
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+import prog8.compiler.loadAsmIncludeFile
+
+
+class CallGraph(private val program: Program): IAstVisitor {
+
+    val modulesImporting = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
+    val modulesImportedBy = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
+    val subroutinesCalling = mutableMapOf<INameScope, List<Subroutine>>().withDefault { mutableListOf() }
+    val subroutinesCalledBy = mutableMapOf<Subroutine, List<Node>>().withDefault { mutableListOf() }
+    // TODO  add dataflow graph: what statements use what variables
+    val usedSymbols = mutableSetOf<Statement>()
+
+    init {
+        visit(program)
+    }
+
+    fun forAllSubroutines(scope: INameScope, sub: (s: Subroutine) -> Unit) {
+        fun findSubs(scope: INameScope) {
+            scope.statements.forEach {
+                if(it is Subroutine)
+                    sub(it)
+                if(it is INameScope)
+                    findSubs(it)
+            }
+        }
+        findSubs(scope)
+    }
+
+    override fun visit(program: Program) {
+        super.visit(program)
+
+        program.modules.forEach {
+            it.importedBy.clear()
+            it.imports.clear()
+
+            it.importedBy.addAll(modulesImportedBy.getValue(it))
+            it.imports.addAll(modulesImporting.getValue(it))
+
+            forAllSubroutines(it) { sub ->
+                sub.calledBy.clear()
+                sub.calls.clear()
+
+                sub.calledBy.addAll(subroutinesCalledBy.getValue(sub))
+                sub.calls.addAll(subroutinesCalling.getValue(sub))
+            }
+
+        }
+
+        val rootmodule = program.modules.first()
+        rootmodule.importedBy.add(rootmodule)       // don't discard root module
+    }
+
+    override fun visit(block: Block) {
+        if(block.definingModule().isLibraryModule) {
+            // make sure the block is not removed
+            addNodeAndParentScopes(block)
+        }
+
+        super.visit(block)
+    }
+
+    override fun visit(directive: Directive) {
+        val thisModule = directive.definingModule()
+        if(directive.directive=="%import") {
+            val importedModule: Module = program.modules.single { it.name==directive.args[0].name }
+            modulesImporting[thisModule] = modulesImporting.getValue(thisModule).plus(importedModule)
+            modulesImportedBy[importedModule] = modulesImportedBy.getValue(importedModule).plus(thisModule)
+        } else if (directive.directive=="%asminclude") {
+            val asm = loadAsmIncludeFile(directive.args[0].str!!, thisModule.source)
+            val scope = directive.definingScope()
+            scanAssemblyCode(asm, directive, scope)
+        }
+
+        super.visit(directive)
+    }
+
+    override fun visit(identifier: IdentifierReference) {
+        // track symbol usage
+        val target = identifier.targetStatement(this.program.namespace)
+        if(target!=null) {
+            addNodeAndParentScopes(target)
+        }
+        super.visit(identifier)
+    }
+
+    private fun addNodeAndParentScopes(stmt: Statement) {
+        usedSymbols.add(stmt)
+        var node: Node=stmt
+        do {
+            if(node is INameScope && node is Statement) {
+                usedSymbols.add(node)
+            }
+            node=node.parent
+        } while (node !is Module && node !is ParentSentinel)
+    }
+
+    override fun visit(subroutine: Subroutine) {
+        val alwaysKeepSubroutines = setOf(
+                Pair("main", "start"),
+                Pair("irq", "irq"),
+                Pair("prog8_lib", "init_system")
+        )
+
+        if(Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines
+                || subroutine.name== initvarsSubName || subroutine.definingModule().isLibraryModule) {
+            // make sure the entrypoint is mentioned in the used symbols
+            addNodeAndParentScopes(subroutine)
+        }
+        super.visit(subroutine)
+    }
+
+    override fun visit(decl: VarDecl) {
+        if(decl.autogeneratedDontRemove || (decl.definingModule().isLibraryModule && decl.type!=VarDeclType.VAR)) {
+            // make sure autogenerated vardecls are in the used symbols
+            addNodeAndParentScopes(decl)
+        }
+
+        if(decl.datatype==DataType.STRUCT)
+            addNodeAndParentScopes(decl)
+
+        super.visit(decl)
+    }
+
+    override fun visit(functionCall: FunctionCall) {
+        val otherSub = functionCall.target.targetSubroutine(program.namespace)
+        if(otherSub!=null) {
+            functionCall.definingSubroutine()?.let { thisSub ->
+                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
+                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCall)
+            }
+        }
+        super.visit(functionCall)
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        val otherSub = functionCallStatement.target.targetSubroutine(program.namespace)
+        if(otherSub!=null) {
+            functionCallStatement.definingSubroutine()?.let { thisSub ->
+                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
+                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCallStatement)
+            }
+        }
+        super.visit(functionCallStatement)
+    }
+
+    override fun visit(jump: Jump) {
+        val otherSub = jump.identifier?.targetSubroutine(program.namespace)
+        if(otherSub!=null) {
+            jump.definingSubroutine()?.let { thisSub ->
+                subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
+                subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(jump)
+            }
+        }
+        super.visit(jump)
+    }
+
+    override fun visit(structDecl: StructDecl) {
+        usedSymbols.add(structDecl)
+        usedSymbols.addAll(structDecl.statements)
+    }
+
+    override fun visit(inlineAssembly: InlineAssembly) {
+        // parse inline asm for subroutine calls (jmp, jsr)
+        val scope = inlineAssembly.definingScope()
+        scanAssemblyCode(inlineAssembly.assembly, inlineAssembly, scope)
+        super.visit(inlineAssembly)
+    }
+
+    private fun scanAssemblyCode(asm: String, context: Statement, scope: INameScope) {
+        val asmJumpRx = Regex("""[\-+a-zA-Z0-9_ \t]+(jmp|jsr)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
+        val asmRefRx = Regex("""[\-+a-zA-Z0-9_ \t]+(...)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
+        asm.lines().forEach { line ->
+            val matches = asmJumpRx.matchEntire(line)
+            if (matches != null) {
+                val jumptarget = matches.groups[2]?.value
+                if (jumptarget != null && (jumptarget[0].isLetter() || jumptarget[0] == '_')) {
+                    val node = program.namespace.lookup(jumptarget.split('.'), context)
+                    if (node is Subroutine) {
+                        subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
+                        subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                    } else if(jumptarget.contains('.')) {
+                        // maybe only the first part already refers to a subroutine
+                        val node2 = program.namespace.lookup(listOf(jumptarget.substringBefore('.')), context)
+                        if (node2 is Subroutine) {
+                            subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node2)
+                            subroutinesCalledBy[node2] = subroutinesCalledBy.getValue(node2).plus(context)
+                        }
+                    }
+                }
+            } else {
+                val matches2 = asmRefRx.matchEntire(line)
+                if (matches2 != null) {
+                    val target= matches2.groups[2]?.value
+                    if (target != null && (target[0].isLetter() || target[0] == '_')) {
+                        if(target.contains('.')) {
+                            val node = program.namespace.lookup(listOf(target.substringBefore('.')), context)
+                            if (node is Subroutine) {
+                                subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
+                                subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

compiler/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -0,0 +1,274 @@
+package prog8.optimizer
+
+import prog8.ast.base.*
+import prog8.ast.expressions.Expression
+import prog8.ast.expressions.NumericLiteralValue
+import kotlin.math.pow
+
+
+class ConstExprEvaluator {
+
+    fun evaluate(left: NumericLiteralValue, operator: String, right: NumericLiteralValue): Expression {
+        return when(operator) {
+            "+" -> plus(left, right)
+            "-" -> minus(left, right)
+            "*" -> multiply(left, right)
+            "/" -> divide(left, right)
+            "%" -> remainder(left, right)
+            "**" -> power(left, right)
+            "&" -> bitwiseand(left, right)
+            "|" -> bitwiseor(left, right)
+            "^" -> bitwisexor(left, right)
+            "and" -> logicaland(left, right)
+            "or" -> logicalor(left, right)
+            "xor" -> logicalxor(left, right)
+            "<" -> NumericLiteralValue.fromBoolean(left < right, left.position)
+            ">" -> NumericLiteralValue.fromBoolean(left > right, left.position)
+            "<=" -> NumericLiteralValue.fromBoolean(left <= right, left.position)
+            ">=" -> NumericLiteralValue.fromBoolean(left >= right, left.position)
+            "==" -> NumericLiteralValue.fromBoolean(left == right, left.position)
+            "!=" -> NumericLiteralValue.fromBoolean(left != right, left.position)
+            "<<" -> shiftedleft(left, right)
+            ">>" -> shiftedright(left, right)
+            else -> throw FatalAstException("const evaluation for invalid operator $operator")
+        }
+    }
+
+    private fun shiftedright(left: NumericLiteralValue, amount: NumericLiteralValue): Expression {
+        if(left.type !in IntegerDatatypes || amount.type !in IntegerDatatypes)
+            throw ExpressionError("cannot compute $left >> $amount", left.position)
+        val result =
+                if(left.type== DataType.UBYTE || left.type== DataType.UWORD)
+                    left.number.toInt().ushr(amount.number.toInt())
+                else
+                    left.number.toInt().shr(amount.number.toInt())
+        return NumericLiteralValue(left.type, result, left.position)
+    }
+
+    private fun shiftedleft(left: NumericLiteralValue, amount: NumericLiteralValue): Expression {
+        if(left.type !in IntegerDatatypes || amount.type !in IntegerDatatypes)
+            throw ExpressionError("cannot compute $left << $amount", left.position)
+        val result = left.number.toInt().shl(amount.number.toInt())
+        return NumericLiteralValue(left.type, result, left.position)
+    }
+
+    private fun logicalxor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot compute $left locical-bitxor $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toInt() != 0), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toDouble() != 0.0), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toInt() != 0), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toDouble() != 0.0), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun logicalor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot compute $left locical-or $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toInt() != 0, left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toDouble() != 0.0, left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toInt() != 0, left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toDouble() != 0.0, left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun logicaland(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot compute $left locical-and $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toInt() != 0, left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toDouble() != 0.0, left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toInt() != 0, left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toDouble() != 0.0, left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun bitwisexor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        if(left.type== DataType.UBYTE) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UBYTE, (left.number.toInt() xor (right.number.toInt() and 255)).toShort(), left.position)
+            }
+        } else if(left.type== DataType.UWORD) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UWORD, left.number.toInt() xor right.number.toInt(), left.position)
+            }
+        }
+        throw ExpressionError("cannot calculate $left ^ $right", left.position)
+    }
+
+    private fun bitwiseor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        if(left.type== DataType.UBYTE) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UBYTE, (left.number.toInt() or (right.number.toInt() and 255)).toShort(), left.position)
+            }
+        } else if(left.type== DataType.UWORD) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UWORD, left.number.toInt() or right.number.toInt(), left.position)
+            }
+        }
+        throw ExpressionError("cannot calculate $left | $right", left.position)
+    }
+
+    private fun bitwiseand(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        if(left.type== DataType.UBYTE) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UBYTE, (left.number.toInt() or (right.number.toInt() and 255)).toShort(), left.position)
+            }
+        } else if(left.type== DataType.UWORD) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteralValue(DataType.UWORD, left.number.toInt() or right.number.toInt(), left.position)
+            }
+        }
+        throw ExpressionError("cannot calculate $left & $right", left.position)
+    }
+
+    private fun power(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot calculate $left ** $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt().toDouble().pow(right.number.toInt()), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt().toDouble().pow(right.number.toDouble()), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toInt()), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toDouble()), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun plus(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot add $left and $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() + right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() + right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun minus(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot subtract $left and $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() - right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() - right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun multiply(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot multiply ${left.type} and ${right.type}"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() * right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() * right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toInt(), left.position)
+                right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toDouble(), left.position)
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun divideByZeroError(pos: Position): Unit =
+            throw ExpressionError("division by zero", pos)
+
+    private fun divide(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot divide $left by $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> {
+                    if(right.number.toInt()==0) divideByZeroError(right.position)
+                    val result: Int = left.number.toInt() / right.number.toInt()
+                    NumericLiteralValue.optimalNumeric(result, left.position)
+                }
+                right.type == DataType.FLOAT -> {
+                    if(right.number.toDouble()==0.0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toInt() / right.number.toDouble(), left.position)
+                }
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> {
+                    if(right.number.toInt()==0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toDouble() / right.number.toInt(), left.position)
+                }
+                right.type == DataType.FLOAT -> {
+                    if(right.number.toDouble()==0.0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toDouble() / right.number.toDouble(), left.position)
+                }
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+
+    private fun remainder(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue {
+        val error = "cannot compute remainder of $left by $right"
+        return when {
+            left.type in IntegerDatatypes -> when {
+                right.type in IntegerDatatypes -> {
+                    if(right.number.toInt()==0) divideByZeroError(right.position)
+                    NumericLiteralValue.optimalNumeric(left.number.toInt().toDouble() % right.number.toInt().toDouble(), left.position)
+                }
+                right.type == DataType.FLOAT -> {
+                    if(right.number.toDouble()==0.0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toInt() % right.number.toDouble(), left.position)
+                }
+                else -> throw ExpressionError(error, left.position)
+            }
+            left.type == DataType.FLOAT -> when {
+                right.type in IntegerDatatypes -> {
+                    if(right.number.toInt()==0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toDouble() % right.number.toInt(), left.position)
+                }
+                right.type == DataType.FLOAT -> {
+                    if(right.number.toDouble()==0.0) divideByZeroError(right.position)
+                    NumericLiteralValue(DataType.FLOAT, left.number.toDouble() % right.number.toDouble(), left.position)
+                }
+                else -> throw ExpressionError(error, left.position)
+            }
+            else -> throw ExpressionError(error, left.position)
+        }
+    }
+}

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -1,194 +1,233 @@
-package prog8.optimizing
+package prog8.optimizer
 
-import prog8.ast.*
-import prog8.compiler.CompilerException
-import prog8.compiler.HeapValues
-import prog8.compiler.IntegerOrAddressOf
-import prog8.compiler.target.c64.FLOAT_MAX_NEGATIVE
-import prog8.compiler.target.c64.FLOAT_MAX_POSITIVE
+import prog8.ast.IFunctionCall
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.fixupArrayDatatype
+import prog8.ast.statements.*
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
+import prog8.functions.BuiltinFunctions
 import kotlin.math.floor
 
 
-class ConstantFolding(private val namespace: INameScope, private val heap: HeapValues) : IAstProcessor {
+class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
     var errors : MutableList<AstException> = mutableListOf()
-
     private val reportedErrorMessages = mutableSetOf<String>()
 
     fun addError(x: AstException) {
-        // check that we don't add the same error more than once
+        // check that we don't add the isSameAs error more than once
         if(x.toString() !in reportedErrorMessages) {
             reportedErrorMessages.add(x.toString())
             errors.add(x)
         }
     }
 
-    override fun process(decl: VarDecl): IStatement {
+    override fun visit(decl: VarDecl): Statement {
         // the initializer value can't refer to the variable itself (recursive definition)
-        if(decl.value?.referencesIdentifier(decl.name) == true || decl.arraysize?.index?.referencesIdentifier(decl.name) == true) {
+        // TODO: use call tree for this?
+        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
             errors.add(ExpressionError("recursive var declaration", decl.position))
             return decl
         }
 
-        val result = super.process(decl)
-
         if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
-            val litval = decl.value as? LiteralValue
-            if(litval!=null && litval.isArray && litval.heapId!=null)
-                fixupArrayTypeOnHeap(decl, litval)
+            if(decl.isArray){
+                if(decl.arraysize==null) {
+                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
+                    val arrayval = (decl.value as? ReferenceLiteralValue)?.array
+                    if(arrayval!=null) {
+                        decl.arraysize = ArrayIndex(NumericLiteralValue.optimalInteger(arrayval.size, decl.position), decl.position)
+                        optimizationsDone++
+                    }
+                }
+                else if(decl.arraysize?.size()==null) {
+                    val size = decl.arraysize!!.index.accept(this)
+                    if(size is NumericLiteralValue) {
+                        decl.arraysize = ArrayIndex(size, decl.position)
+                        optimizationsDone++
+                    }
+                }
+            }
+
             when(decl.datatype) {
                 DataType.FLOAT -> {
                     // vardecl: for scalar float vars, promote constant integer initialization values to floats
-                    if (litval != null && litval.type in IntegerDatatypes) {
-                        val newValue = LiteralValue(DataType.FLOAT, floatvalue = litval.asNumericValue!!.toDouble(), position = litval.position)
+                    val litval = decl.value as? NumericLiteralValue
+                    if (litval!=null && litval.type in IntegerDatatypes) {
+                        val newValue = NumericLiteralValue(DataType.FLOAT, litval.number.toDouble(), litval.position)
                         decl.value = newValue
+                        optimizationsDone++
+                        return super.visit(decl)
                     }
                 }
+                in StringDatatypes -> {
+                    // nothing to do for strings
+                }
+                DataType.STRUCT -> {
+                    // struct defintions don't have anything else in them
+                }
                 DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                    val numericLv = decl.value as? NumericLiteralValue
                     val rangeExpr = decl.value as? RangeExpr
                     if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array (will be put on heap later)
+                        // convert the initializer range expression to an actual array
                         val declArraySize = decl.arraysize?.size()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size(heap))
+                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
                             errors.add(ExpressionError("range expression size doesn't match declared array size", decl.value?.position!!))
-                        val constRange = rangeExpr.toConstantIntegerRange(heap)
+                        val constRange = rangeExpr.toConstantIntegerRange()
                         if(constRange!=null) {
-                            val eltType = rangeExpr.resultingDatatype(namespace, heap)!!
+                            val eltType = rangeExpr.inferType(program)!!
                             if(eltType in ByteDatatypes) {
-                                decl.value = LiteralValue(decl.datatype,
-                                        arrayvalue = constRange.map { LiteralValue(eltType, bytevalue=it.toShort(), position = decl.value!!.position ) }
-                                                .toTypedArray(), position=decl.value!!.position)
+                                decl.value = ReferenceLiteralValue(decl.datatype,
+                                        array = constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }
+                                                .toTypedArray(), position = decl.value!!.position)
                             } else {
-                                decl.value = LiteralValue(decl.datatype,
-                                        arrayvalue = constRange.map { LiteralValue(eltType, wordvalue= it, position = decl.value!!.position ) }
-                                                .toTypedArray(), position=decl.value!!.position)
+                                decl.value = ReferenceLiteralValue(decl.datatype,
+                                        array = constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }
+                                                .toTypedArray(), position = decl.value!!.position)
                             }
                             decl.value!!.linkParents(decl)
+                            optimizationsDone++
+                            return super.visit(decl)
                         }
                     }
-                    if(litval?.type==DataType.FLOAT)
-                        errors.add(ExpressionError("arraysize requires only integers here", litval.position))
-                    if(decl.arraysize==null)
-                        return decl
-                    val size = decl.arraysize!!.size()
-                    if ((litval==null || !litval.isArray) && size != null && rangeExpr==null) {
+                    if(numericLv!=null && numericLv.type== DataType.FLOAT)
+                        errors.add(ExpressionError("arraysize requires only integers here", numericLv.position))
+                    val size = decl.arraysize?.size() ?: return decl
+                    if (rangeExpr==null && numericLv!=null) {
                         // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
-                        val fillvalue = if (litval == null) 0 else litval.asIntegerValue ?: 0
+                        val fillvalue = numericLv.number.toInt()
                         when(decl.datatype){
                             DataType.ARRAY_UB -> {
                                 if(fillvalue !in 0..255)
-                                    errors.add(ExpressionError("ubyte value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("ubyte value overflow", numericLv.position))
                             }
                             DataType.ARRAY_B -> {
                                 if(fillvalue !in -128..127)
-                                    errors.add(ExpressionError("byte value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("byte value overflow", numericLv.position))
                             }
                             DataType.ARRAY_UW -> {
                                 if(fillvalue !in 0..65535)
-                                    errors.add(ExpressionError("uword value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("uword value overflow", numericLv.position))
                             }
                             DataType.ARRAY_W -> {
                                 if(fillvalue !in -32768..32767)
-                                    errors.add(ExpressionError("word value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("word value overflow", numericLv.position))
                             }
                             else -> {}
                         }
-                        val heapId = heap.addIntegerArray(decl.datatype, Array(size) { IntegerOrAddressOf(fillvalue, null) })
-                        decl.value = LiteralValue(decl.datatype, heapId = heapId, position = litval?.position ?: decl.position)
+                        // create the array itself, filled with the fillvalue.
+                        val array = Array(size) {fillvalue}.map { NumericLiteralValue.optimalInteger(it, numericLv.position) as Expression}.toTypedArray()
+                        val refValue = ReferenceLiteralValue(decl.datatype, array = array, position = numericLv.position)
+                        refValue.addToHeap(program.heap)
+                        decl.value = refValue
+                        refValue.parent=decl
+                        optimizationsDone++
+                        return super.visit(decl)
                     }
                 }
                 DataType.ARRAY_F  -> {
-                    if(decl.arraysize==null)
-                        return decl
-                    val size = decl.arraysize!!.size()
-                    if ((litval==null || !litval.isArray) && size != null) {
-                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
-                        val fillvalue = if (litval == null) 0.0 else litval.asNumericValue?.toDouble() ?: 0.0
-                        if(fillvalue< FLOAT_MAX_NEGATIVE || fillvalue> FLOAT_MAX_POSITIVE)
-                            errors.add(ExpressionError("float value overflow", litval?.position ?: decl.position))
+                    val size = decl.arraysize?.size() ?: return decl
+                    val litval = decl.value as? NumericLiteralValue
+                    if(litval==null) {
+                        // there's no initialization value, but the size is known, so we're ok.
+                        return super.visit(decl)
+                    } else {
+                        // arraysize initializer is a single int, and we know the size.
+                        val fillvalue = litval.number.toDouble()
+                        if (fillvalue < FLOAT_MAX_NEGATIVE || fillvalue > FLOAT_MAX_POSITIVE)
+                            errors.add(ExpressionError("float value overflow", litval.position))
                         else {
-                            val heapId = heap.addDoublesArray(DoubleArray(size) { fillvalue })
-                            decl.value = LiteralValue(DataType.ARRAY_F, heapId = heapId, position = litval?.position ?: decl.position)
+                            // create the array itself, filled with the fillvalue.
+                            val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) as Expression}.toTypedArray()
+                            val refValue = ReferenceLiteralValue(DataType.ARRAY_F, array = array, position = litval.position)
+                            refValue.addToHeap(program.heap)
+                            decl.value = refValue
+                            refValue.parent=decl
+                            optimizationsDone++
+                            return super.visit(decl)
                         }
                     }
                 }
-                else -> return result
-            }
-        }
-        return result
-    }
-
-    private fun fixupArrayTypeOnHeap(decl: VarDecl, litval: LiteralValue) {
-        // fix the type of the array value that's on the heap, to match the vardecl.
-        // notice that checking the bounds of the actual values is not done here, but in the AstChecker later.
-
-        if(decl.datatype==litval.type)
-            return   // already correct datatype
-        val heapId = litval.heapId ?: throw FatalAstException("expected array to be on heap $litval")
-        val array=heap.get(heapId)
-        when(decl.datatype) {
-            DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                if(array.array!=null) {
-                    heap.update(heapId, HeapValues.HeapValue(decl.datatype, null, array.array, null))
-                    decl.value = LiteralValue(decl.datatype, heapId=heapId, position = litval.position)
+                else -> {
+                    // nothing to do for this type
                 }
             }
-            DataType.ARRAY_F -> {
-                if(array.array!=null) {
-                    // convert a non-float array to floats
-                    val doubleArray = array.array.map { it.integer!!.toDouble() }.toDoubleArray()
-                    heap.update(heapId, HeapValues.HeapValue(DataType.ARRAY_F, null, null, doubleArray))
-                    decl.value = LiteralValue(decl.datatype, heapId = heapId, position = litval.position)
-                }
-            }
-            else -> throw FatalAstException("invalid array vardecl type ${decl.datatype}")
         }
+
+        return super.visit(decl)
     }
 
     /**
      * replace identifiers that refer to const value, with the value itself (if it's a simple type)
      */
-    override fun process(identifier: IdentifierReference): IExpression {
+    override fun visit(identifier: IdentifierReference): Expression {
         return try {
-            val cval = identifier.constValue(namespace, heap) ?: return identifier
-            return if(cval.isNumeric) {
-                val copy = LiteralValue(cval.type, cval.bytevalue, cval.wordvalue, cval.floatvalue, null, cval.arrayvalue, position = identifier.position)
-                copy.parent = identifier.parent
-                copy
-            } else
-                identifier
+            val cval = identifier.constValue(program) ?: return identifier
+            return when {
+                cval.type in NumericDatatypes -> {
+                    val copy = NumericLiteralValue(cval.type, cval.number, identifier.position)
+                    copy.parent = identifier.parent
+                    copy
+                }
+                cval.type in PassByReferenceDatatypes -> TODO("ref type $identifier")
+                else -> identifier
+            }
         } catch (ax: AstException) {
             addError(ax)
             identifier
         }
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): Expression {
         return try {
-            super.process(functionCall)
+            super.visit(functionCall)
             typeCastConstArguments(functionCall)
-            functionCall.constValue(namespace, heap) ?: functionCall
+            functionCall.constValue(program) ?: functionCall
         } catch (ax: AstException) {
             addError(ax)
             functionCall
         }
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        super.process(functionCallStatement)
+    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
+        super.visit(functionCallStatement)
         typeCastConstArguments(functionCallStatement)
         return functionCallStatement
     }
 
     private fun typeCastConstArguments(functionCall: IFunctionCall) {
-        val subroutine = functionCall.target.targetSubroutine(namespace)
+        if(functionCall.target.nameInSource.size==1) {
+            val builtinFunction = BuiltinFunctions[functionCall.target.nameInSource.single()]
+            if(builtinFunction!=null) {
+                // match the arguments of a builtin function signature.
+                for(arg in functionCall.arglist.withIndex().zip(builtinFunction.parameters)) {
+                    val possibleDts = arg.second.possibleDatatypes
+                    val argConst = arg.first.value.constValue(program)
+                    if(argConst!=null && argConst.type !in possibleDts) {
+                        val convertedValue = argConst.cast(possibleDts.first())
+                        if(convertedValue!=null) {
+                            functionCall.arglist[arg.first.index] = convertedValue
+                            optimizationsDone++
+                        }
+                    }
+                }
+                return
+            }
+        }
+        // match the arguments of a subroutine.
+        val subroutine = functionCall.target.targetSubroutine(program.namespace)
         if(subroutine!=null) {
             // if types differ, try to typecast constant arguments to the function call to the desired data type of the parameter
             for(arg in functionCall.arglist.withIndex().zip(subroutine.parameters)) {
                 val expectedDt = arg.second.type
-                val argConst = arg.first.value.constValue(namespace, heap)
+                val argConst = arg.first.value.constValue(program)
                 if(argConst!=null && argConst.type!=expectedDt) {
-                    val convertedValue = argConst.intoDatatype(expectedDt)
+                    val convertedValue = argConst.cast(expectedDt)
                     if(convertedValue!=null) {
                         functionCall.arglist[arg.first.index] = convertedValue
                         optimizationsDone++
@@ -198,69 +237,56 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
         }
     }
 
-    override fun process(memread: DirectMemoryRead): IExpression {
+    override fun visit(memread: DirectMemoryRead): Expression {
         // @( &thing )  -->  thing
         val addrOf = memread.addressExpression as? AddressOf
         if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memread)
-    }
-
-    override fun process(memwrite: DirectMemoryWrite): IExpression {
-        // @( &thing )  -->  thing
-        val addrOf = memwrite.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memwrite)
+            return super.visit(addrOf.identifier)
+        return super.visit(memread)
     }
 
     /**
-     * Try to process a unary prefix expression.
+     * Try to accept a unary prefix expression.
      * Compile-time constant sub expressions will be evaluated on the spot.
      * For instance, the expression for "- 4.5" will be optimized into the float literal -4.5
      */
-    override fun process(expr: PrefixExpression): IExpression {
+    override fun visit(expr: PrefixExpression): Expression {
         return try {
-            super.process(expr)
+            val prefixExpr=super.visit(expr)
+            if(prefixExpr !is PrefixExpression)
+                return prefixExpr
 
-            val subexpr = expr.expression
-            if (subexpr is LiteralValue) {
-                // process prefixed literal values (such as -3, not true)
+            val subexpr = prefixExpr.expression
+            if (subexpr is NumericLiteralValue) {
+                // accept prefixed literal values (such as -3, not true)
                 return when {
-                    expr.operator == "+" -> subexpr
-                    expr.operator == "-" -> when {
-                        subexpr.asIntegerValue!= null -> {
+                    prefixExpr.operator == "+" -> subexpr
+                    prefixExpr.operator == "-" -> when {
+                        subexpr.type in IntegerDatatypes -> {
                             optimizationsDone++
-                            LiteralValue.optimalNumeric(-subexpr.asIntegerValue, subexpr.position)
+                            NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position)
                         }
-                        subexpr.floatvalue != null -> {
+                        subexpr.type == DataType.FLOAT -> {
                             optimizationsDone++
-                            LiteralValue(DataType.FLOAT, floatvalue = -subexpr.floatvalue, position = subexpr.position)
+                            NumericLiteralValue(DataType.FLOAT, -subexpr.number.toDouble(), subexpr.position)
                         }
                         else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
                     }
-                    expr.operator == "~" -> when {
-                        subexpr.asIntegerValue != null -> {
+                    prefixExpr.operator == "~" -> when {
+                        subexpr.type in IntegerDatatypes -> {
                             optimizationsDone++
-                            LiteralValue.optimalNumeric(subexpr.asIntegerValue.inv(), subexpr.position)
+                            NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position)
                         }
                         else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
                     }
-                    expr.operator == "not" -> when {
-                        subexpr.asIntegerValue != null -> {
-                            optimizationsDone++
-                            LiteralValue.fromBoolean(subexpr.asIntegerValue == 0, subexpr.position)
-                        }
-                        subexpr.floatvalue != null -> {
-                            optimizationsDone++
-                            LiteralValue.fromBoolean(subexpr.floatvalue == 0.0, subexpr.position)
-                        }
-                        else -> throw ExpressionError("can not take logical not of $subexpr", subexpr.position)
+                    prefixExpr.operator == "not" -> {
+                        optimizationsDone++
+                        NumericLiteralValue.fromBoolean(subexpr.number.toDouble() == 0.0, subexpr.position)
                     }
-                    else -> throw ExpressionError(expr.operator, subexpr.position)
+                    else -> throw ExpressionError(prefixExpr.operator, subexpr.position)
                 }
             }
-            return expr
+            return prefixExpr
         } catch (ax: AstException) {
             addError(ax)
             expr
@@ -268,7 +294,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
     }
 
     /**
-     * Try to process a binary expression.
+     * Try to accept a binary expression.
      * Compile-time constant sub expressions will be evaluated on the spot.
      * For instance, "9 * (4 + 2)" will be optimized into the integer literal 54.
      *
@@ -284,11 +310,15 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
      *        (X / c1) * c2  ->  X / (c2/c1)
      *        (X + c1) - c2  ->  X + (c1-c2)
      */
-    override fun process(expr: BinaryExpression): IExpression {
+    override fun visit(expr: BinaryExpression): Expression {
         return try {
-            super.process(expr)
-            val leftconst = expr.left.constValue(namespace, heap)
-            val rightconst = expr.right.constValue(namespace, heap)
+            super.visit(expr)
+
+            if(expr.left is ReferenceLiteralValue || expr.right is ReferenceLiteralValue)
+                TODO("binexpr with reference litval")
+
+            val leftconst = expr.left.constValue(program)
+            val rightconst = expr.right.constValue(program)
 
             val subExpr: BinaryExpression? = when {
                 leftconst!=null -> expr.right as? BinaryExpression
@@ -296,8 +326,8 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
                 else -> null
             }
             if(subExpr!=null) {
-                val subleftconst = subExpr.left.constValue(namespace, heap)
-                val subrightconst = subExpr.right.constValue(namespace, heap)
+                val subleftconst = subExpr.left.constValue(program)
+                val subrightconst = subExpr.right.constValue(program)
                 if ((subleftconst != null && subrightconst == null) || (subleftconst==null && subrightconst!=null)) {
                     // try reordering.
                     return groupTwoConstsTogether(expr, subExpr,
@@ -307,12 +337,13 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
             }
 
             // const fold when both operands are a const
-            val evaluator = ConstExprEvaluator()
             return when {
                 leftconst != null && rightconst != null -> {
                     optimizationsDone++
-                    evaluator.evaluate(leftconst, expr.operator, rightconst, heap)
+                    val evaluator = ConstExprEvaluator()
+                    evaluator.evaluate(leftconst, expr.operator, rightconst)
                 }
+
                 else -> expr
             }
         } catch (ax: AstException) {
@@ -326,11 +357,11 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
                                        leftIsConst: Boolean,
                                        rightIsConst: Boolean,
                                        subleftIsConst: Boolean,
-                                       subrightIsConst: Boolean): IExpression
+                                       subrightIsConst: Boolean): Expression
     {
         // @todo this implements only a small set of possible reorderings for now
         if(expr.operator==subExpr.operator) {
-            // both operators are the same.
+            // both operators are the isSameAs.
             // If + or *,  we can simply swap the const of expr and Var in subexpr.
             if(expr.operator=="+" || expr.operator=="*") {
                 if(leftIsConst) {
@@ -361,7 +392,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
                         expr
                     } else
                         BinaryExpression(
-                                BinaryExpression(expr.left, if(expr.operator=="-") "+" else "*", subExpr.right, subExpr.position),
+                                BinaryExpression(expr.left, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
                                 expr.operator, subExpr.left, expr.position)
                 } else {
                     return if(subleftIsConst) {
@@ -370,7 +401,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
                     } else
                         BinaryExpression(
                                 subExpr.left, expr.operator,
-                                BinaryExpression(expr.right, if(expr.operator=="-") "+" else "*", subExpr.right, subExpr.position),
+                                BinaryExpression(expr.right, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
                                 expr.position)
                 }
             }
@@ -513,50 +544,50 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
         }
     }
 
-    override fun process(forLoop: ForLoop): IStatement {
+    override fun visit(forLoop: ForLoop): Statement {
 
-        fun adjustRangeDt(rangeFrom: LiteralValue, targetDt: DataType, rangeTo: LiteralValue, stepLiteral: LiteralValue?, range: RangeExpr): RangeExpr {
-            val newFrom = rangeFrom.intoDatatype(targetDt)
-            val newTo = rangeTo.intoDatatype(targetDt)
+        fun adjustRangeDt(rangeFrom: NumericLiteralValue, targetDt: DataType, rangeTo: NumericLiteralValue, stepLiteral: NumericLiteralValue?, range: RangeExpr): RangeExpr {
+            val newFrom = rangeFrom.cast(targetDt)
+            val newTo = rangeTo.cast(targetDt)
             if (newFrom != null && newTo != null) {
-                val newStep: IExpression =
-                        if (stepLiteral != null) (stepLiteral.intoDatatype(targetDt) ?: stepLiteral) else range.step
+                val newStep: Expression =
+                        if (stepLiteral != null) (stepLiteral.cast(targetDt) ?: stepLiteral) else range.step
                 return RangeExpr(newFrom, newTo, newStep, range.position)
             }
             return range
         }
 
         // adjust the datatype of a range expression in for loops to the loop variable.
-        val resultStmt = super.process(forLoop) as ForLoop
+        val resultStmt = super.visit(forLoop) as ForLoop
         val iterableRange = resultStmt.iterable as? RangeExpr ?: return resultStmt
-        val rangeFrom = iterableRange.from as? LiteralValue
-        val rangeTo = iterableRange.to as? LiteralValue
+        val rangeFrom = iterableRange.from as? NumericLiteralValue
+        val rangeTo = iterableRange.to as? NumericLiteralValue
         if(rangeFrom==null || rangeTo==null) return resultStmt
 
-        val loopvar = resultStmt.loopVar!!.targetVarDecl(namespace)
+        val loopvar = resultStmt.loopVar?.targetVarDecl(program.namespace)
         if(loopvar!=null) {
-            val stepLiteral = iterableRange.step as? LiteralValue
+            val stepLiteral = iterableRange.step as? NumericLiteralValue
             when(loopvar.datatype) {
                 DataType.UBYTE -> {
-                    if(rangeFrom.type!=DataType.UBYTE) {
+                    if(rangeFrom.type!= DataType.UBYTE) {
                         // attempt to translate the iterable into ubyte values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.BYTE -> {
-                    if(rangeFrom.type!=DataType.BYTE) {
+                    if(rangeFrom.type!= DataType.BYTE) {
                         // attempt to translate the iterable into byte values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.UWORD -> {
-                    if(rangeFrom.type!=DataType.UWORD) {
+                    if(rangeFrom.type!= DataType.UWORD) {
                         // attempt to translate the iterable into uword values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.WORD -> {
-                    if(rangeFrom.type!=DataType.WORD) {
+                    if(rangeFrom.type!= DataType.WORD) {
                         // attempt to translate the iterable into word values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
@@ -567,145 +598,77 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
         return resultStmt
     }
 
-    override fun process(literalValue: LiteralValue): LiteralValue {
-        if(literalValue.isString) {
-            // intern the string; move it into the heap
-            if(literalValue.strvalue(heap).length !in 1..255)
-                addError(ExpressionError("string literal length must be between 1 and 255", literalValue.position))
-            else {
-                val heapId = heap.addString(literalValue.type, literalValue.strvalue(heap))     // TODO: we don't know the actual string type yet, STR != STR_S etc...
-                val newValue = LiteralValue(literalValue.type, heapId = heapId, position = literalValue.position)
-                return super.process(newValue)
-            }
-        } else if(literalValue.arrayvalue!=null) {
-            return moveArrayToHeap(literalValue)
-        }
-
-        return super.process(literalValue)
-    }
-
-    private fun moveArrayToHeap(arraylit: LiteralValue): LiteralValue {
-        val array: Array<IExpression> = arraylit.arrayvalue!!.map { it.process(this) }.toTypedArray()
-        val allElementsAreConstantOrAddressOf = array.fold(true) { c, expr-> c and (expr is LiteralValue || expr is AddressOf)}
-        if(!allElementsAreConstantOrAddressOf) {
-            addError(ExpressionError("array literal can only consist of constant primitive numerical values or memory pointers", arraylit.position))
-            return arraylit
-        } else if(array.any {it is AddressOf}) {
-            val arrayDt = DataType.ARRAY_UW
-            val intArrayWithAddressOfs = array.map {
-                when (it) {
-                    is AddressOf -> IntegerOrAddressOf(null, it)
-                    is LiteralValue -> IntegerOrAddressOf(it.asIntegerValue, null)
-                    else -> throw CompilerException("invalid datatype in array")
+    override fun visit(refLiteral: ReferenceLiteralValue): Expression {
+        val litval = super.visit(refLiteral)
+        if(litval is ReferenceLiteralValue) {
+            if (litval.isArray) {
+                val vardecl = litval.parent as? VarDecl
+                if (vardecl!=null) {
+                    return fixupArrayDatatype(litval, vardecl, program.heap)
                 }
             }
-            val heapId = heap.addIntegerArray(arrayDt, intArrayWithAddressOfs.toTypedArray())
-            return LiteralValue(arrayDt, heapId = heapId, position = arraylit.position)
-        } else {
-            // array is only constant numerical values
-            val valuesInArray = array.map { it.constValue(namespace, heap)!!.asNumericValue!! }
-            val integerArray = valuesInArray.map{ it.toInt() }
-            val doubleArray = valuesInArray.map{it.toDouble()}.toDoubleArray()
-            val typesInArray: Set<DataType> = array.mapNotNull { it.resultingDatatype(namespace, heap) }.toSet()
-
-            // Take an educated guess about the array type.
-            // This may be altered (if needed & if possible) to suit an array declaration type later!
-            // Also, the check if all values are valid for the given datatype is done later, in the AstChecker.
-            val arrayDt =
-                    if(DataType.FLOAT in typesInArray)
-                        DataType.ARRAY_F
-                    else if(DataType.WORD in typesInArray) {
-                        DataType.ARRAY_W
-                    } else {
-                        val maxValue = integerArray.max()!!
-                        val minValue = integerArray.min()!!
-                        if (minValue >= 0) {
-                            // unsigned
-                            if (maxValue <= 255)
-                                DataType.ARRAY_UB
-                            else
-                                DataType.ARRAY_UW
-                        } else {
-                            // signed
-                            if (maxValue <= 127)
-                                DataType.ARRAY_B
-                            else
-                                DataType.ARRAY_W
-                        }
-                    }
-
-            val heapId = when(arrayDt) {
-                DataType.ARRAY_UB,
-                DataType.ARRAY_B,
-                DataType.ARRAY_UW,
-                DataType.ARRAY_W -> heap.addIntegerArray(arrayDt, integerArray.map { IntegerOrAddressOf(it, null) }.toTypedArray())
-                DataType.ARRAY_F -> heap.addDoublesArray(doubleArray)
-                else -> throw CompilerException("invalid arraysize type")
-            }
-            return LiteralValue(arrayDt, heapId = heapId, position = arraylit.position)
         }
+        return litval
     }
 
-    override fun process(assignment: Assignment): IStatement {
-        super.process(assignment)
-        val lv = assignment.value as? LiteralValue
+    override fun visit(assignment: Assignment): Statement {
+        super.visit(assignment)
+        val lv = assignment.value as? NumericLiteralValue
         if(lv!=null) {
-            val targetDt = assignment.singleTarget?.determineDatatype(namespace, heap, assignment)
             // see if we can promote/convert a literal value to the required datatype
-            when(targetDt) {
+            when(assignment.target.inferType(program, assignment)) {
                 DataType.UWORD -> {
                     // we can convert to UWORD: any UBYTE, BYTE/WORD that are >=0, FLOAT that's an integer 0..65535,
-                    if(lv.type==DataType.UBYTE)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.BYTE && lv.bytevalue!!>=0)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.WORD && lv.wordvalue!!>=0)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
-                        val d = lv.floatvalue!!
+                    if(lv.type== DataType.UBYTE)
+                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
+                    else if(lv.type== DataType.BYTE && lv.number.toInt()>=0)
+                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
+                    else if(lv.type== DataType.WORD && lv.number.toInt()>=0)
+                        assignment.value = NumericLiteralValue(DataType.UWORD, lv.number.toInt(), lv.position)
+                    else if(lv.type== DataType.FLOAT) {
+                        val d = lv.number.toDouble()
                         if(floor(d)==d && d>=0 && d<=65535)
-                            assignment.value = LiteralValue(DataType.UWORD, wordvalue=floor(d).toInt(), position=lv.position)
+                            assignment.value = NumericLiteralValue(DataType.UWORD, floor(d).toInt(), lv.position)
                     }
                 }
                 DataType.UBYTE -> {
                     // we can convert to UBYTE: UWORD <=255, BYTE >=0, FLOAT that's an integer 0..255,
-                    if(lv.type==DataType.UWORD && lv.wordvalue!! <= 255)
-                        assignment.value = LiteralValue(DataType.UBYTE, lv.wordvalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.BYTE && lv.bytevalue!! >=0)
-                        assignment.value = LiteralValue(DataType.UBYTE, lv.bytevalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
-                        val d = lv.floatvalue!!
+                    if(lv.type== DataType.UWORD && lv.number.toInt() <= 255)
+                        assignment.value = NumericLiteralValue(DataType.UBYTE, lv.number.toShort(), lv.position)
+                    else if(lv.type== DataType.BYTE && lv.number.toInt() >=0)
+                        assignment.value = NumericLiteralValue(DataType.UBYTE, lv.number.toShort(), lv.position)
+                    else if(lv.type== DataType.FLOAT) {
+                        val d = lv.number.toDouble()
                         if(floor(d)==d && d >=0 && d<=255)
-                            assignment.value = LiteralValue(DataType.UBYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = NumericLiteralValue(DataType.UBYTE, floor(d).toShort(), lv.position)
                     }
                 }
                 DataType.BYTE -> {
                     // we can convert to BYTE: UWORD/UBYTE <= 127, FLOAT that's an integer 0..127
-                    if(lv.type==DataType.UWORD && lv.wordvalue!! <= 127)
-                        assignment.value = LiteralValue(DataType.BYTE, lv.wordvalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.UBYTE && lv.bytevalue!! <= 127)
-                        assignment.value = LiteralValue(DataType.BYTE, lv.bytevalue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
-                        val d = lv.floatvalue!!
+                    if(lv.type== DataType.UWORD && lv.number.toInt() <= 127)
+                        assignment.value = NumericLiteralValue(DataType.BYTE, lv.number.toShort(), lv.position)
+                    else if(lv.type== DataType.UBYTE && lv.number.toInt() <= 127)
+                        assignment.value = NumericLiteralValue(DataType.BYTE, lv.number.toShort(), lv.position)
+                    else if(lv.type== DataType.FLOAT) {
+                        val d = lv.number.toDouble()
                         if(floor(d)==d && d>=0 && d<=127)
-                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = NumericLiteralValue(DataType.BYTE, floor(d).toShort(), lv.position)
                     }
                 }
                 DataType.WORD -> {
                     // we can convert to WORD: any UBYTE/BYTE, UWORD <= 32767, FLOAT that's an integer -32768..32767,
-                    if(lv.type==DataType.UBYTE || lv.type==DataType.BYTE)
-                        assignment.value = LiteralValue(DataType.WORD, wordvalue=lv.bytevalue!!.toInt(), position=lv.position)
-                    else if(lv.type==DataType.UWORD && lv.wordvalue!! <= 32767)
-                        assignment.value = LiteralValue(DataType.WORD, wordvalue=lv.wordvalue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
-                        val d = lv.floatvalue!!
+                    if(lv.type== DataType.UBYTE || lv.type== DataType.BYTE)
+                        assignment.value = NumericLiteralValue(DataType.WORD, lv.number.toInt(), lv.position)
+                    else if(lv.type== DataType.UWORD && lv.number.toInt() <= 32767)
+                        assignment.value = NumericLiteralValue(DataType.WORD, lv.number.toInt(), lv.position)
+                    else if(lv.type== DataType.FLOAT) {
+                        val d = lv.number.toDouble()
                         if(floor(d)==d && d>=-32768 && d<=32767)
-                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = NumericLiteralValue(DataType.BYTE, floor(d).toShort(), lv.position)
                     }
                 }
                 DataType.FLOAT -> {
-                    if(lv.isNumeric)
-                        assignment.value = LiteralValue(DataType.FLOAT, floatvalue= lv.asNumericValue?.toDouble(), position=lv.position)
+                    assignment.value = NumericLiteralValue(DataType.FLOAT, lv.number.toDouble(), lv.position)
                 }
                 else -> {}
             }

compiler/src/prog8/optimizer/Extensions.kt

@@ -0,0 +1,42 @@
+package prog8.optimizer
+
+import prog8.ast.Program
+import prog8.ast.base.AstException
+import prog8.parser.ParsingFailedError
+
+
+internal fun Program.constantFold() {
+    val optimizer = ConstantFolding(this)
+    try {
+        optimizer.visit(this)
+    } catch (ax: AstException) {
+        optimizer.addError(ax)
+    }
+
+    while(optimizer.errors.isEmpty() && optimizer.optimizationsDone>0) {
+        optimizer.optimizationsDone = 0
+        optimizer.visit(this)
+    }
+
+    if(optimizer.errors.isNotEmpty()) {
+        optimizer.errors.forEach { System.err.println(it) }
+        throw ParsingFailedError("There are ${optimizer.errors.size} errors.")
+    } else {
+        modules.forEach { it.linkParents(namespace) }   // re-link in final configuration
+    }
+}
+
+
+internal fun Program.optimizeStatements(optimizeInlining: Boolean): Int {
+    val optimizer = StatementOptimizer(this, optimizeInlining)
+    optimizer.visit(this)
+    modules.forEach { it.linkParents(this.namespace) }   // re-link in final configuration
+
+    return optimizer.optimizationsDone
+}
+
+internal fun Program.simplifyExpressions() : Int {
+    val optimizer = SimplifyExpressions(this)
+    optimizer.visit(this)
+    return optimizer.optimizationsDone
+}

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -1,44 +1,92 @@
-package prog8.optimizing
+package prog8.optimizer
 
-import prog8.ast.*
-import prog8.compiler.HeapValues
+import prog8.ast.Program
+import prog8.ast.base.AstException
+import prog8.ast.base.DataType
+import prog8.ast.base.IntegerDatatypes
+import prog8.ast.base.NumericDatatypes
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.Statement
 import kotlin.math.abs
 import kotlin.math.log2
 
 /*
     todo advanced expression optimization: common (sub) expression elimination (turn common expressions into single subroutine call + introduce variable to hold it)
+
+    Also see  https://egorbo.com/peephole-optimizations.html
+
  */
 
-class SimplifyExpressions(private val namespace: INameScope, private val heap: HeapValues) : IAstProcessor {
+internal class SimplifyExpressions(private val program: Program) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
 
-    override fun process(assignment: Assignment): IStatement {
+    override fun visit(assignment: Assignment): Statement {
         if (assignment.aug_op != null)
             throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
-        return super.process(assignment)
+        return super.visit(assignment)
     }
 
-    override fun process(memread: DirectMemoryRead): IExpression {
+    override fun visit(memread: DirectMemoryRead): Expression {
         // @( &thing )  -->  thing
         val addrOf = memread.addressExpression as? AddressOf
         if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memread)
+            return super.visit(addrOf.identifier)
+        return super.visit(memread)
     }
 
-    override fun process(memwrite: DirectMemoryWrite): IExpression {
-        // @( &thing )  -->  thing
-        val addrOf = memwrite.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memwrite)
+    override fun visit(typecast: TypecastExpression): Expression {
+        var tc = typecast
+
+        // try to statically convert a literal value into one of the desired type
+        val literal = tc.expression as? NumericLiteralValue
+        if(literal!=null) {
+            val newLiteral = literal.cast(tc.type)
+            if(newLiteral!=null && newLiteral!==literal) {
+                optimizationsDone++
+                return newLiteral
+            }
+        }
+
+        // remove redundant typecasts
+        while(true) {
+            val expr = tc.expression
+            if(expr !is TypecastExpression || expr.type!=tc.type) {
+                val assignment = typecast.parent as? Assignment
+                if(assignment!=null) {
+                    val targetDt = assignment.target.inferType(program, assignment)
+                    if(tc.expression.inferType(program)==targetDt) {
+                        optimizationsDone++
+                        return tc.expression
+                    }
+                }
+
+                val subTc = tc.expression as? TypecastExpression
+                if(subTc!=null) {
+                    // if the previous typecast was casting to a 'bigger' type, just ignore that one
+                    // if the previous typecast was casting to a similar type, ignore that one
+                    if(subTc.type largerThan tc.type || subTc.type equalsSize tc.type) {
+                        subTc.type = tc.type
+                        subTc.parent = tc.parent
+                        optimizationsDone++
+                        return subTc
+                    }
+                }
+
+                return super.visit(tc)
+            }
+
+            optimizationsDone++
+            tc = expr
+        }
     }
 
-    override fun process(expr: PrefixExpression): IExpression {
+    override fun visit(expr: PrefixExpression): Expression {
         if (expr.operator == "+") {
             // +X --> X
             optimizationsDone++
-            return expr.expression.process(this)
+            return expr.expression.accept(this)
         } else if (expr.operator == "not") {
             (expr.expression as? BinaryExpression)?.let {
                 // NOT (...)  ->   invert  ...
@@ -78,18 +126,18 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                 }
             }
         }
-        return super.process(expr)
+        return super.visit(expr)
     }
 
-    override fun process(expr: BinaryExpression): IExpression {
-        super.process(expr)
-        val leftVal = expr.left.constValue(namespace, heap)
-        val rightVal = expr.right.constValue(namespace, heap)
-        val constTrue = LiteralValue.fromBoolean(true, expr.position)
-        val constFalse = LiteralValue.fromBoolean(false, expr.position)
+    override fun visit(expr: BinaryExpression): Expression {
+        super.visit(expr)
+        val leftVal = expr.left.constValue(program)
+        val rightVal = expr.right.constValue(program)
+        val constTrue = NumericLiteralValue.fromBoolean(true, expr.position)
+        val constFalse = NumericLiteralValue.fromBoolean(false, expr.position)
 
-        val leftDt = expr.left.resultingDatatype(namespace, heap)
-        val rightDt = expr.right.resultingDatatype(namespace, heap)
+        val leftDt = expr.left.inferType(program)
+        val rightDt = expr.right.inferType(program)
         if (leftDt != null && rightDt != null && leftDt != rightDt) {
             // try to convert a datatype into the other (where ddd
             if (adjustDatatypes(expr, leftVal, leftDt, rightVal, rightDt)) {
@@ -127,10 +175,10 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
 
         // X + (-value)  -->  X - value
         if (expr.operator == "+" && rightVal != null) {
-            val rv = rightVal.asNumericValue?.toDouble()
-            if (rv != null && rv < 0.0) {
+            val rv = rightVal.number.toDouble()
+            if (rv < 0.0) {
                 expr.operator = "-"
-                expr.right = LiteralValue.fromNumber(-rv, rightVal.type, rightVal.position)
+                expr.right = NumericLiteralValue(rightVal.type, -rv, rightVal.position)
                 optimizationsDone++
                 return expr
             }
@@ -138,10 +186,10 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
 
         // (-value) + X  -->  X - value
         if (expr.operator == "+" && leftVal != null) {
-            val lv = leftVal.asNumericValue?.toDouble()
-            if (lv != null && lv < 0.0) {
+            val lv = leftVal.number.toDouble()
+            if (lv < 0.0) {
                 expr.operator = "-"
-                expr.right = LiteralValue.fromNumber(-lv, leftVal.type, leftVal.position)
+                expr.right = NumericLiteralValue(leftVal.type, -lv, leftVal.position)
                 optimizationsDone++
                 return expr
             }
@@ -157,10 +205,10 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
 
         // X - (-value)  -->  X + value
         if (expr.operator == "-" && rightVal != null) {
-            val rv = rightVal.asNumericValue?.toDouble()
-            if (rv != null && rv < 0.0) {
+            val rv = rightVal.number.toDouble()
+            if (rv < 0.0) {
                 expr.operator = "+"
-                expr.right = LiteralValue.fromNumber(-rv, rightVal.type, rightVal.position)
+                expr.right = NumericLiteralValue(rightVal.type, -rv, rightVal.position)
                 optimizationsDone++
                 return expr
             }
@@ -178,7 +226,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                     val x = expr.right
                     val y = determineY(x, leftBinExpr)
                     if(y!=null) {
-                        val yPlus1 = BinaryExpression(y, "+", LiteralValue.fromNumber(1, leftDt!!, y.position), y.position)
+                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue(leftDt!!, 1, y.position), y.position)
                         return BinaryExpression(x, "*", yPlus1, x.position)
                     }
                 } else {
@@ -187,7 +235,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                     val x = expr.right
                     val y = determineY(x, leftBinExpr)
                     if(y!=null) {
-                        val yMinus1 = BinaryExpression(y, "-", LiteralValue.fromNumber(1, leftDt!!, y.position), y.position)
+                        val yMinus1 = BinaryExpression(y, "-", NumericLiteralValue(leftDt!!, 1, y.position), y.position)
                         return BinaryExpression(x, "*", yMinus1, x.position)
                     }
                 }
@@ -199,7 +247,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                     val x = expr.left
                     val y = determineY(x, rightBinExpr)
                     if(y!=null) {
-                        val yPlus1 = BinaryExpression(y, "+", LiteralValue.optimalInteger(1, y.position), y.position)
+                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue.optimalInteger(1, y.position), y.position)
                         return BinaryExpression(x, "*", yPlus1, x.position)
                     }
                 } else {
@@ -208,7 +256,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                     val x = expr.left
                     val y = determineY(x, rightBinExpr)
                     if(y!=null) {
-                        val oneMinusY = BinaryExpression(LiteralValue.optimalInteger(1, y.position), "-", y, y.position)
+                        val oneMinusY = BinaryExpression(NumericLiteralValue.optimalInteger(1, y.position), "-", y, y.position)
                         return BinaryExpression(x, "*", oneMinusY, x.position)
                     }
                 }
@@ -294,67 +342,67 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         return expr
     }
 
-    private fun determineY(x: IExpression, subBinExpr: BinaryExpression): IExpression? {
+    private fun determineY(x: Expression, subBinExpr: BinaryExpression): Expression? {
         return when {
-            same(subBinExpr.left, x) -> subBinExpr.right
-            same(subBinExpr.right, x) -> subBinExpr.left
+            subBinExpr.left isSameAs x -> subBinExpr.right
+            subBinExpr.right isSameAs x -> subBinExpr.left
             else -> null
         }
     }
 
     private fun adjustDatatypes(expr: BinaryExpression,
-                                leftConstVal: LiteralValue?, leftDt: DataType,
-                                rightConstVal: LiteralValue?, rightDt: DataType): Boolean {
+                                leftConstVal: NumericLiteralValue?, leftDt: DataType,
+                                rightConstVal: NumericLiteralValue?, rightDt: DataType): Boolean {
 
-        fun adjust(value: LiteralValue, targetDt: DataType): Pair<Boolean, LiteralValue>{
+        fun adjust(value: NumericLiteralValue, targetDt: DataType): Pair<Boolean, NumericLiteralValue>{
             if(value.type==targetDt)
                 return Pair(false, value)
             when(value.type) {
                 DataType.UBYTE -> {
                     if (targetDt == DataType.BYTE) {
-                        if(value.bytevalue!! < 127)
-                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position=value.position))
+                        if(value.number.toInt() < 127)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                     else if (targetDt == DataType.UWORD || targetDt == DataType.WORD)
-                        return Pair(true, LiteralValue(targetDt, wordvalue = value.bytevalue!!.toInt(), position=value.position))
+                        return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
                 }
                 DataType.BYTE -> {
                     if (targetDt == DataType.UBYTE) {
-                        if(value.bytevalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position=value.position))
+                        if(value.number.toInt() >= 0)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
                     }
                     else if (targetDt == DataType.UWORD) {
-                        if(value.bytevalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, wordvalue=value.bytevalue.toInt(), position=value.position))
+                        if(value.number.toInt() >= 0)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
                     }
-                    else if (targetDt == DataType.WORD) return Pair(true, LiteralValue(targetDt, wordvalue=value.bytevalue!!.toInt(), position=value.position))
+                    else if (targetDt == DataType.WORD) return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
                 }
                 DataType.UWORD -> {
                     if (targetDt == DataType.UBYTE) {
-                        if(value.wordvalue!! <= 255)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                        if(value.number.toInt() <= 255)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                     else if (targetDt == DataType.BYTE) {
-                        if(value.wordvalue!! <= 127)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                        if(value.number.toInt() <= 127)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                     else if (targetDt == DataType.WORD) {
-                        if(value.wordvalue!! <= 32767)
-                            return Pair(true, LiteralValue(targetDt, wordvalue=value.wordvalue, position=value.position))
+                        if(value.number.toInt() <= 32767)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toInt(), value.position))
                     }
                 }
                 DataType.WORD -> {
                     if (targetDt == DataType.UBYTE) {
-                        if(value.wordvalue!! in 0..255)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                        if(value.number.toInt() in 0..255)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                     else if (targetDt == DataType.BYTE) {
-                        if(value.wordvalue!! in -128..127)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                        if(value.number.toInt() in -128..127)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                     else if (targetDt == DataType.UWORD) {
-                        if(value.wordvalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                        if(value.number.toInt() >= 0)
+                            return Pair(true, NumericLiteralValue(targetDt, value.number.toShort(), value.position))
                     }
                 }
                 else -> {}
@@ -363,7 +411,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         }
 
         if(leftConstVal==null && rightConstVal!=null) {
-            if(isBiggerType(leftDt, rightDt)) {
+            if(leftDt largerThan rightDt) {
                 val (adjusted, newValue) = adjust(rightConstVal, leftDt)
                 if (adjusted) {
                     expr.right = newValue
@@ -373,7 +421,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
             }
             return false
         } else if(leftConstVal!=null && rightConstVal==null) {
-            if(isBiggerType(rightDt, leftDt)) {
+            if(rightDt largerThan leftDt) {
                 val (adjusted, newValue) = adjust(leftConstVal, rightDt)
                 if (adjusted) {
                     expr.left = newValue
@@ -387,37 +435,29 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         }
     }
 
-    private fun isBiggerType(type: DataType, other: DataType) =
-        when(type) {
-            in ByteDatatypes -> false
-            in WordDatatypes -> other in ByteDatatypes
-            else -> true
-        }
+    private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: NumericLiteralValue?, val rightVal: NumericLiteralValue?)
 
-
-    private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: LiteralValue?, val rightVal: LiteralValue?)
-
-    private fun reorderAssociative(expr: BinaryExpression, leftVal: LiteralValue?): ReorderedAssociativeBinaryExpr {
+    private fun reorderAssociative(expr: BinaryExpression, leftVal: NumericLiteralValue?): ReorderedAssociativeBinaryExpr {
         if(expr.operator in associativeOperators && leftVal!=null) {
             // swap left and right so that right is always the constant
             val tmp = expr.left
             expr.left = expr.right
             expr.right = tmp
             optimizationsDone++
-            return ReorderedAssociativeBinaryExpr(expr, expr.right.constValue(namespace, heap), leftVal)
+            return ReorderedAssociativeBinaryExpr(expr, expr.right.constValue(program), leftVal)
         }
-        return ReorderedAssociativeBinaryExpr(expr, leftVal, expr.right.constValue(namespace, heap))
+        return ReorderedAssociativeBinaryExpr(expr, leftVal, expr.right.constValue(program))
     }
 
-    private fun optimizeAdd(pexpr: BinaryExpression, pleftVal: LiteralValue?, prightVal: LiteralValue?): IExpression {
+    private fun optimizeAdd(pexpr: BinaryExpression, pleftVal: NumericLiteralValue?, prightVal: NumericLiteralValue?): Expression {
         if(pleftVal==null && prightVal==null)
             return pexpr
 
         val (expr, _, rightVal) = reorderAssociative(pexpr, pleftVal)
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
-            val rightConst: LiteralValue = rightVal
-            when(rightConst.asNumericValue?.toDouble()) {
+            val rightConst: NumericLiteralValue = rightVal
+            when(rightConst.number.toDouble()) {
                 0.0 -> {
                     // left
                     optimizationsDone++
@@ -430,14 +470,14 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         return expr
     }
 
-    private fun optimizeSub(expr: BinaryExpression, leftVal: LiteralValue?, rightVal: LiteralValue?): IExpression {
+    private fun optimizeSub(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
         if(leftVal==null && rightVal==null)
             return expr
 
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
-            val rightConst: LiteralValue = rightVal
-            when(rightConst.asNumericValue?.toDouble()) {
+            val rightConst: NumericLiteralValue = rightVal
+            when(rightConst.number.toDouble()) {
                 0.0 -> {
                     // left
                     optimizationsDone++
@@ -447,7 +487,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         }
         if(leftVal!=null) {
             // left value is a constant, see if we can optimize
-            when(leftVal.asNumericValue?.toDouble()) {
+            when(leftVal.number.toDouble()) {
                 0.0 -> {
                     // -right
                     optimizationsDone++
@@ -459,38 +499,38 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         return expr
     }
 
-    private fun optimizePower(expr: BinaryExpression, leftVal: LiteralValue?, rightVal: LiteralValue?): IExpression {
+    private fun optimizePower(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
         if(leftVal==null && rightVal==null)
             return expr
 
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
-            val rightConst: LiteralValue = rightVal
-            when(rightConst.asNumericValue?.toDouble()) {
+            val rightConst: NumericLiteralValue = rightVal
+            when(rightConst.number.toDouble()) {
                 -3.0 -> {
                     // -1/(left*left*left)
                     optimizationsDone++
-                    return BinaryExpression(LiteralValue(DataType.FLOAT, floatvalue = -1.0, position = expr.position), "/",
+                    return BinaryExpression(NumericLiteralValue(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)
                     optimizationsDone++
-                    return BinaryExpression(LiteralValue(DataType.FLOAT, floatvalue = -1.0, position = expr.position), "/",
+                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
                             BinaryExpression(expr.left, "*", expr.left, expr.position),
                             expr.position)
                 }
                 -1.0 -> {
                     // -1/left
                     optimizationsDone++
-                    return BinaryExpression(LiteralValue(DataType.FLOAT, floatvalue = -1.0, position = expr.position), "/",
+                    return BinaryExpression(NumericLiteralValue(DataType.FLOAT, -1.0, expr.position), "/",
                             expr.left, expr.position)
                 }
                 0.0 -> {
                     // 1
                     optimizationsDone++
-                    return LiteralValue.fromNumber(1, rightConst.type, expr.position)
+                    return NumericLiteralValue(rightConst.type, 1, expr.position)
                 }
                 0.5 -> {
                     // sqrt(left)
@@ -516,21 +556,21 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         }
         if(leftVal!=null) {
             // left value is a constant, see if we can optimize
-            when(leftVal.asNumericValue?.toDouble()) {
+            when(leftVal.number.toDouble()) {
                 -1.0 -> {
                     // -1
                     optimizationsDone++
-                    return LiteralValue(DataType.FLOAT, floatvalue = -1.0, position = expr.position)
+                    return NumericLiteralValue(DataType.FLOAT, -1.0, expr.position)
                 }
                 0.0 -> {
                     // 0
                     optimizationsDone++
-                    return LiteralValue.fromNumber(0, leftVal.type, expr.position)
+                    return NumericLiteralValue(leftVal.type, 0, expr.position)
                 }
                 1.0 -> {
                     //1
                     optimizationsDone++
-                    return LiteralValue.fromNumber(1, leftVal.type, expr.position)
+                    return NumericLiteralValue(leftVal.type, 1, expr.position)
                 }
 
             }
@@ -539,22 +579,22 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         return expr
     }
 
-    private fun optimizeRemainder(expr: BinaryExpression, leftVal: LiteralValue?, rightVal: LiteralValue?): IExpression {
+    private fun optimizeRemainder(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
         if(leftVal==null && rightVal==null)
             return expr
 
         // simplify assignments  A = B <operator> C
 
-        val cv = rightVal?.asIntegerValue?.toDouble()
+        val cv = rightVal?.number?.toInt()?.toDouble()
         when(expr.operator) {
             "%" -> {
                 if (cv == 1.0) {
                     optimizationsDone++
-                    return LiteralValue.fromNumber(0, expr.resultingDatatype(namespace, heap)!!, expr.position)
+                    return NumericLiteralValue(expr.inferType(program)!!, 0, expr.position)
                 } else if (cv == 2.0) {
                     optimizationsDone++
                     expr.operator = "&"
-                    expr.right = LiteralValue.optimalInteger(1, expr.position)
+                    expr.right = NumericLiteralValue.optimalInteger(1, expr.position)
                     return expr
                 }
             }
@@ -563,7 +603,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
 
     }
 
-    private fun optimizeDivision(expr: BinaryExpression, leftVal: LiteralValue?, rightVal: LiteralValue?): IExpression {
+    private fun optimizeDivision(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
         if(leftVal==null && rightVal==null)
             return expr
 
@@ -571,9 +611,9 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
 
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
-            val rightConst: LiteralValue = rightVal
-            val cv = rightConst.asNumericValue?.toDouble()
-            val leftDt = expr.left.resultingDatatype(namespace, heap)
+            val rightConst: NumericLiteralValue = rightVal
+            val cv = rightConst.number.toDouble()
+            val leftDt = expr.left.inferType(program)
             when(cv) {
                 -1.0 -> {
                     //  '/' -> -left
@@ -594,7 +634,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                         // divided by a power of two => shift right
                         optimizationsDone++
                         val numshifts = log2(cv).toInt()
-                        return BinaryExpression(expr.left, ">>", LiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                        return BinaryExpression(expr.left, ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
                 -2.0, -4.0, -8.0, -16.0, -32.0, -64.0, -128.0, -256.0, -512.0, -1024.0, -2048.0, -4096.0, -8192.0, -16384.0, -32768.0, -65536.0 -> {
@@ -602,32 +642,32 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                         // divided by a negative power of two => negate, then shift right
                         optimizationsDone++
                         val numshifts = log2(-cv).toInt()
-                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), ">>", LiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), ">>", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
             }
 
             if (leftDt == DataType.UBYTE) {
-                if(abs(rightConst.asNumericValue!!.toDouble()) >= 256.0) {
+                if(abs(rightConst.number.toDouble()) >= 256.0) {
                     optimizationsDone++
-                    return LiteralValue(DataType.UBYTE, 0, position = expr.position)
+                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
                 }
             }
             else if (leftDt == DataType.UWORD) {
-                if(abs(rightConst.asNumericValue!!.toDouble()) >= 65536.0) {
+                if(abs(rightConst.number.toDouble()) >= 65536.0) {
                     optimizationsDone++
-                    return LiteralValue(DataType.UBYTE, 0, position = expr.position)
+                    return NumericLiteralValue(DataType.UBYTE, 0, expr.position)
                 }
             }
         }
 
         if(leftVal!=null) {
             // left value is a constant, see if we can optimize
-            when(leftVal.asNumericValue?.toDouble()) {
+            when(leftVal.number.toDouble()) {
                 0.0 -> {
                     // 0
                     optimizationsDone++
-                    return LiteralValue.fromNumber(0, leftVal.type, expr.position)
+                    return NumericLiteralValue(leftVal.type, 0, expr.position)
                 }
             }
         }
@@ -635,17 +675,16 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         return expr
     }
 
-    private fun optimizeMultiplication(pexpr: BinaryExpression, pleftVal: LiteralValue?, prightVal: LiteralValue?): IExpression {
+    private fun optimizeMultiplication(pexpr: BinaryExpression, pleftVal: NumericLiteralValue?, prightVal: NumericLiteralValue?): Expression {
         if(pleftVal==null && prightVal==null)
             return pexpr
 
         val (expr, _, rightVal) = reorderAssociative(pexpr, pleftVal)
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
-            val leftValue: IExpression = expr.left
-            val rightConst: LiteralValue = rightVal
-            val cv = rightConst.asNumericValue?.toDouble()
-            when(cv) {
+            val leftValue: Expression = expr.left
+            val rightConst: NumericLiteralValue = rightVal
+            when(val cv = rightConst.number.toDouble()) {
                 -1.0 -> {
                     // -left
                     optimizationsDone++
@@ -654,7 +693,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                 0.0 -> {
                     // 0
                     optimizationsDone++
-                    return LiteralValue.fromNumber(0, rightConst.type, expr.position)
+                    return NumericLiteralValue(rightConst.type, 0, expr.position)
                 }
                 1.0 -> {
                     // left
@@ -662,19 +701,19 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
                     return expr.left
                 }
                 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0, 1024.0, 2048.0, 4096.0, 8192.0, 16384.0, 32768.0, 65536.0 -> {
-                    if(leftValue.resultingDatatype(namespace, heap) in IntegerDatatypes) {
+                    if(leftValue.inferType(program) in IntegerDatatypes) {
                         // times a power of two => shift left
                         optimizationsDone++
                         val numshifts = log2(cv).toInt()
-                        return BinaryExpression(expr.left, "<<", LiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                        return BinaryExpression(expr.left, "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
                 -2.0, -4.0, -8.0, -16.0, -32.0, -64.0, -128.0, -256.0, -512.0, -1024.0, -2048.0, -4096.0, -8192.0, -16384.0, -32768.0, -65536.0 -> {
-                    if(leftValue.resultingDatatype(namespace, heap) in IntegerDatatypes) {
+                    if(leftValue.inferType(program) in IntegerDatatypes) {
                         // times a negative power of two => negate, then shift left
                         optimizationsDone++
                         val numshifts = log2(-cv).toInt()
-                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), "<<", LiteralValue.optimalInteger(numshifts, expr.position), expr.position)
+                        return BinaryExpression(PrefixExpression("-", expr.left, expr.position), "<<", NumericLiteralValue.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
             }

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -0,0 +1,671 @@
+package prog8.optimizer
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+import prog8.compiler.target.c64.Petscii
+import prog8.functions.BuiltinFunctions
+import kotlin.math.floor
+
+
+/*
+    todo: subroutines with 1 or 2 byte args or 1 word arg can be converted to asm sub calling convention (args in registers)
+    todo analyse for unreachable code and remove that (f.i. code after goto or return that has no label so can never be jumped to) + print warning about this
+*/
+
+
+internal class StatementOptimizer(private val program: Program, private val optimizeInlining: Boolean) : IAstModifyingVisitor {
+    var optimizationsDone: Int = 0
+        private set
+
+    private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
+    private val callgraph = CallGraph(program)
+    private var generatedLabelSequenceNumber = 0
+
+    override fun visit(program: Program) {
+        removeUnusedCode(callgraph)
+        if(optimizeInlining) {
+            inlineSubroutines(callgraph)
+        }
+        super.visit(program)
+    }
+
+    private fun inlineSubroutines(callgraph: CallGraph) {
+        val entrypoint = program.entrypoint()
+        program.modules.forEach {
+            callgraph.forAllSubroutines(it) { sub ->
+                if(sub!==entrypoint && !sub.isAsmSubroutine) {
+                    if (sub.statements.size <= 3 && !sub.expensiveToInline) {
+                        sub.calledBy.toList().forEach { caller -> inlineSubroutine(sub, caller) }
+                    } else if (sub.calledBy.size==1 && sub.statements.size < 50) {
+                        inlineSubroutine(sub, sub.calledBy[0])
+                    } else if(sub.calledBy.size<=3 && sub.statements.size < 10 && !sub.expensiveToInline) {
+                        sub.calledBy.toList().forEach { caller -> inlineSubroutine(sub, caller) }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun inlineSubroutine(sub: Subroutine, caller: Node) {
+        // if the sub is called multiple times from the isSameAs scope, we can't inline (would result in duplicate definitions)
+        // (unless we add a sequence number to all vars/labels and references to them in the inlined code, but I skip that for now)
+        val scope = caller.definingScope()
+        if(sub.calledBy.count { it.definingScope()===scope } > 1)
+            return
+        if(caller !is IFunctionCall || caller !is Statement || sub.statements.any { it is Subroutine })
+            return
+
+        if(sub.parameters.isEmpty() && sub.returntypes.isEmpty()) {
+            // sub without params and without return value can be easily inlined
+            val parent = caller.parent as INameScope
+            val inlined = AnonymousScope(sub.statements.toMutableList(), caller.position)
+            parent.statements[parent.statements.indexOf(caller)] = inlined
+            // replace return statements in the inlined sub by a jump to the end of it
+            var haveNewEndLabel = false
+            var endLabelUsed = false
+            var endlabel = inlined.statements.last() as? Label
+            if(endlabel==null) {
+                endlabel = makeLabel("_prog8_auto_sub_end", inlined.statements.last().position)
+                endlabel.parent = inlined
+                haveNewEndLabel = true
+            }
+            val returns = inlined.statements.withIndex().filter { iv -> iv.value is Return }.map { iv -> Pair(iv.index, iv.value as Return)}
+            for(returnIdx in returns) {
+                val jump = Jump(null, IdentifierReference(listOf(endlabel.name), returnIdx.second.position), null, returnIdx.second.position)
+                inlined.statements[returnIdx.first] = jump
+                endLabelUsed = true
+            }
+            if(endLabelUsed && haveNewEndLabel)
+                inlined.statements.add(endlabel)
+            inlined.linkParents(caller.parent)
+            sub.calledBy.remove(caller)     // if there are no callers left, the sub will be removed automatically later
+            optimizationsDone++
+        } else {
+            // TODO inline subroutine that has params or returnvalues or both
+        }
+    }
+
+    private fun makeLabel(name: String, position: Position): Label {
+        generatedLabelSequenceNumber++
+        return Label("${name}_$generatedLabelSequenceNumber", position)
+    }
+
+    private fun removeUnusedCode(callgraph: CallGraph) {
+        // remove all subroutines that aren't called, or are empty
+        val removeSubroutines = mutableSetOf<Subroutine>()
+        val entrypoint = program.entrypoint()
+        program.modules.forEach {
+            callgraph.forAllSubroutines(it) { sub ->
+                if (sub !== entrypoint && !sub.keepAlways && (sub.calledBy.isEmpty() || (sub.containsNoCodeNorVars() && !sub.isAsmSubroutine)))
+                    removeSubroutines.add(sub)
+            }
+        }
+
+        if (removeSubroutines.isNotEmpty()) {
+            removeSubroutines.forEach {
+                it.definingScope().remove(it)
+            }
+        }
+
+        val removeBlocks = mutableSetOf<Block>()
+        program.modules.flatMap { it.statements }.filterIsInstance<Block>().forEach { block ->
+            if (block.containsNoCodeNorVars() && "force_output" !in block.options())
+                removeBlocks.add(block)
+        }
+
+        if (removeBlocks.isNotEmpty()) {
+            removeBlocks.forEach { it.definingScope().remove(it) }
+        }
+
+        // remove modules that are not imported, or are empty (unless it's a library modules)
+        val removeModules = mutableSetOf<Module>()
+        program.modules.forEach {
+            if (!it.isLibraryModule && (it.importedBy.isEmpty() || it.containsNoCodeNorVars()))
+                removeModules.add(it)
+        }
+
+        if (removeModules.isNotEmpty()) {
+            program.modules.removeAll(removeModules)
+        }
+    }
+
+    override fun visit(block: Block): Statement {
+        if("force_output" !in block.options()) {
+            if (block.containsNoCodeNorVars()) {
+                optimizationsDone++
+                printWarning("removing empty block '${block.name}'", block.position)
+                return NopStatement.insteadOf(block)
+            }
+
+            if (block !in callgraph.usedSymbols) {
+                optimizationsDone++
+                printWarning("removing unused block '${block.name}'", block.position)
+                return NopStatement.insteadOf(block)  // remove unused block
+            }
+        }
+
+        return super.visit(block)
+    }
+
+    override fun visit(subroutine: Subroutine): Statement {
+        super.visit(subroutine)
+        val forceOutput = "force_output" in subroutine.definingBlock().options()
+        if(subroutine.asmAddress==null && !forceOutput) {
+            if(subroutine.containsNoCodeNorVars()) {
+                printWarning("removing empty subroutine '${subroutine.name}'", subroutine.position)
+                optimizationsDone++
+                return NopStatement.insteadOf(subroutine)
+            }
+        }
+
+        val linesToRemove = deduplicateAssignments(subroutine.statements)
+        if(linesToRemove.isNotEmpty()) {
+            linesToRemove.reversed().forEach{subroutine.statements.removeAt(it)}
+        }
+
+        if(subroutine.canBeAsmSubroutine) {
+            optimizationsDone++
+            return subroutine.intoAsmSubroutine()   // TODO this doesn't work yet due to parameter vardecl issue
+
+            // TODO fix parameter passing so this also works:
+//            asmsub aa(byte arg @ Y) -> clobbers() -> () {
+//                byte local = arg            ; @todo fix 'undefined symbol arg' by some sort of alias name for the parameter
+//                A=44
+//            }
+
+        }
+
+        if(subroutine !in callgraph.usedSymbols && !forceOutput) {
+            printWarning("removing unused subroutine '${subroutine.name}'", subroutine.position)
+            optimizationsDone++
+            return NopStatement.insteadOf(subroutine)
+        }
+
+        return subroutine
+    }
+
+    override fun visit(decl: VarDecl): Statement {
+        val forceOutput = "force_output" in decl.definingBlock().options()
+        if(decl !in callgraph.usedSymbols && !forceOutput) {
+            if(decl.type == VarDeclType.VAR)
+                printWarning("removing unused variable ${decl.type} '${decl.name}'", decl.position)
+            optimizationsDone++
+            return NopStatement.insteadOf(decl)
+        }
+
+        return super.visit(decl)
+    }
+
+    private fun deduplicateAssignments(statements: List<Statement>): MutableList<Int> {
+        // removes 'duplicate' assignments that assign the isSameAs target
+        val linesToRemove = mutableListOf<Int>()
+        var previousAssignmentLine: Int? = null
+        for (i in 0 until statements.size) {
+            val stmt = statements[i] as? Assignment
+            if (stmt != null && stmt.value is NumericLiteralValue) {
+                if (previousAssignmentLine == null) {
+                    previousAssignmentLine = i
+                    continue
+                } else {
+                    val prev = statements[previousAssignmentLine] as Assignment
+                    if (prev.target.isSameAs(stmt.target, program)) {
+                        // get rid of the previous assignment, if the target is not MEMORY
+                        if (prev.target.isNotMemory(program.namespace))
+                            linesToRemove.add(previousAssignmentLine)
+                    }
+                    previousAssignmentLine = i
+                }
+            } else
+                previousAssignmentLine = null
+        }
+        return linesToRemove
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement): Statement {
+        if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
+            val functionName = functionCallStatement.target.nameInSource[0]
+            if (functionName in pureBuiltinFunctions) {
+                printWarning("statement has no effect (function return value is discarded)", functionCallStatement.position)
+                optimizationsDone++
+                return NopStatement.insteadOf(functionCallStatement)
+            }
+        }
+
+        if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") ||
+                functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) {
+            // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
+            val stringVar = functionCallStatement.arglist.single() as? IdentifierReference
+            if(stringVar!=null) {
+                val heapId = stringVar.heapId(program.namespace)
+                val string = program.heap.get(heapId).str!!
+                if(string.length==1) {
+                    val petscii = Petscii.encodePetscii(string, true)[0]
+                    functionCallStatement.arglist.clear()
+                    functionCallStatement.arglist.add(NumericLiteralValue.optimalInteger(petscii.toInt(), functionCallStatement.position))
+                    functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
+                    optimizationsDone++
+                    return functionCallStatement
+                } else if(string.length==2) {
+                    val petscii = Petscii.encodePetscii(string, true)
+                    val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
+                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
+                            mutableListOf(NumericLiteralValue.optimalInteger(petscii[0].toInt(), functionCallStatement.position)), functionCallStatement.position))
+                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
+                            mutableListOf(NumericLiteralValue.optimalInteger(petscii[1].toInt(), functionCallStatement.position)), functionCallStatement.position))
+                    optimizationsDone++
+                    return scope
+                }
+            }
+        }
+
+        // if it calls a subroutine,
+        // and the first instruction in the subroutine is a jump, call that jump target instead
+        // if the first instruction in the subroutine is a return statement, replace with a nop instruction
+        val subroutine = functionCallStatement.target.targetSubroutine(program.namespace)
+        if(subroutine!=null) {
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is Jump && first.identifier!=null) {
+                optimizationsDone++
+                return FunctionCallStatement(first.identifier, functionCallStatement.arglist, functionCallStatement.position)
+            }
+            if(first is ReturnFromIrq || first is Return) {
+                optimizationsDone++
+                return NopStatement.insteadOf(functionCallStatement)
+            }
+        }
+
+        return super.visit(functionCallStatement)
+    }
+
+    override fun visit(functionCall: FunctionCall): Expression {
+        // if it calls a subroutine,
+        // and the first instruction in the subroutine is a jump, call that jump target instead
+        // if the first instruction in the subroutine is a return statement with constant value, replace with the constant value
+        val subroutine = functionCall.target.targetSubroutine(program.namespace)
+        if(subroutine!=null) {
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is Jump && first.identifier!=null) {
+                optimizationsDone++
+                return FunctionCall(first.identifier, functionCall.arglist, functionCall.position)
+            }
+            if(first is Return && first.value!=null) {
+                val constval = first.value?.constValue(program)
+                if(constval!=null)
+                    return constval
+            }
+        }
+        return super.visit(functionCall)
+    }
+
+    override fun visit(ifStatement: IfStatement): Statement {
+        super.visit(ifStatement)
+
+        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsNoCodeNorVars()) {
+            optimizationsDone++
+            return NopStatement.insteadOf(ifStatement)
+        }
+
+        if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsCodeOrVars()) {
+            // invert the condition and move else part to true part
+            ifStatement.truepart = ifStatement.elsepart
+            ifStatement.elsepart = AnonymousScope(mutableListOf(), ifStatement.elsepart.position)
+            ifStatement.condition = PrefixExpression("not", ifStatement.condition, ifStatement.condition.position)
+            optimizationsDone++
+            return ifStatement
+        }
+
+        val constvalue = ifStatement.condition.constValue(program)
+        if(constvalue!=null) {
+            return if(constvalue.asBooleanValue){
+                // always true -> keep only if-part
+                printWarning("condition is always true", ifStatement.position)
+                optimizationsDone++
+                ifStatement.truepart
+            } else {
+                // always false -> keep only else-part
+                printWarning("condition is always false", ifStatement.position)
+                optimizationsDone++
+                ifStatement.elsepart
+            }
+        }
+        return ifStatement
+    }
+
+    override fun visit(forLoop: ForLoop): Statement {
+        super.visit(forLoop)
+        if(forLoop.body.containsNoCodeNorVars()) {
+            // remove empty for loop
+            optimizationsDone++
+            return NopStatement.insteadOf(forLoop)
+        } else if(forLoop.body.statements.size==1) {
+            val loopvar = forLoop.body.statements[0] as? VarDecl
+            if(loopvar!=null && loopvar.name==forLoop.loopVar?.nameInSource?.singleOrNull()) {
+                // remove empty for loop
+                optimizationsDone++
+                return NopStatement.insteadOf(forLoop)
+            }
+        }
+
+
+        val range = forLoop.iterable as? RangeExpr
+        if(range!=null) {
+            if(range.size()==1) {
+                // for loop over a (constant) range of just a single value-- optimize the loop away
+                // loopvar/reg = range value , follow by block
+                val assignment = Assignment(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, null, forLoop.position), null, range.from, forLoop.position)
+                forLoop.body.statements.add(0, assignment)
+                optimizationsDone++
+                return forLoop.body
+            }
+        }
+        return forLoop
+    }
+
+    override fun visit(whileLoop: WhileLoop): Statement {
+        super.visit(whileLoop)
+        val constvalue = whileLoop.condition.constValue(program)
+        if(constvalue!=null) {
+            return if(constvalue.asBooleanValue){
+                // always true -> print a warning, and optimize into body + jump (if there are no continue and break statements)
+                printWarning("condition is always true", whileLoop.position)
+                if(hasContinueOrBreak(whileLoop.body))
+                    return whileLoop
+                val label = Label("_prog8_back", whileLoop.condition.position)
+                whileLoop.body.statements.add(0, label)
+                whileLoop.body.statements.add(Jump(null,
+                        IdentifierReference(listOf("_prog8_back"), whileLoop.condition.position),
+                        null, whileLoop.condition.position))
+                optimizationsDone++
+                return whileLoop.body
+            } else {
+                // always false -> ditch whole statement
+                printWarning("condition is always false", whileLoop.position)
+                optimizationsDone++
+                NopStatement.insteadOf(whileLoop)
+            }
+        }
+        return whileLoop
+    }
+
+    override fun visit(repeatLoop: RepeatLoop): Statement {
+        super.visit(repeatLoop)
+        val constvalue = repeatLoop.untilCondition.constValue(program)
+        if(constvalue!=null) {
+            return if(constvalue.asBooleanValue){
+                // always true -> keep only the statement block (if there are no continue and break statements)
+                printWarning("condition is always true", repeatLoop.position)
+                if(hasContinueOrBreak(repeatLoop.body))
+                    repeatLoop
+                else {
+                    optimizationsDone++
+                    repeatLoop.body
+                }
+            } else {
+                // always false -> print a warning, and optimize into body + jump (if there are no continue and break statements)
+                printWarning("condition is always false", repeatLoop.position)
+                if(hasContinueOrBreak(repeatLoop.body))
+                    return repeatLoop
+                val label = Label("__back", repeatLoop.untilCondition.position)
+                repeatLoop.body.statements.add(0, label)
+                repeatLoop.body.statements.add(Jump(null,
+                        IdentifierReference(listOf("__back"), repeatLoop.untilCondition.position),
+                        null, repeatLoop.untilCondition.position))
+                optimizationsDone++
+                return repeatLoop.body
+            }
+        }
+        return repeatLoop
+    }
+
+    override fun visit(whenStatement: WhenStatement): Statement {
+        val choices = whenStatement.choices.toList()
+        for(choice in choices) {
+            if(choice.statements.containsNoCodeNorVars())
+                whenStatement.choices.remove(choice)
+        }
+        return super.visit(whenStatement)
+    }
+
+    private fun hasContinueOrBreak(scope: INameScope): Boolean {
+
+        class Searcher: IAstModifyingVisitor
+        {
+            var count=0
+
+            override fun visit(breakStmt: Break): Statement {
+                count++
+                return super.visit(breakStmt)
+            }
+
+            override fun visit(contStmt: Continue): Statement {
+                count++
+                return super.visit(contStmt)
+            }
+        }
+        val s=Searcher()
+        for(stmt in scope.statements) {
+            stmt.accept(s)
+            if(s.count>0)
+                return true
+        }
+        return s.count > 0
+    }
+
+    override fun visit(jump: Jump): Statement {
+        val subroutine = jump.identifier?.targetSubroutine(program.namespace)
+        if(subroutine!=null) {
+            // if the first instruction in the subroutine is another jump, shortcut this one
+            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
+            if(first is Jump) {
+                optimizationsDone++
+                return first
+            }
+        }
+
+        // if the jump is to the next statement, remove the jump
+        val scope = jump.definingScope()
+        val label = jump.identifier?.targetStatement(scope)
+        if(label!=null) {
+            if(scope.statements.indexOf(label) == scope.statements.indexOf(jump)+1) {
+                optimizationsDone++
+                return NopStatement.insteadOf(jump)
+            }
+        }
+
+        return jump
+    }
+
+    override fun visit(assignment: Assignment): Statement {
+        if(assignment.aug_op!=null)
+            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
+
+        if(assignment.target isSameAs assignment.value) {
+            if(assignment.target.isNotMemory(program.namespace)) {
+                optimizationsDone++
+                return NopStatement.insteadOf(assignment)
+            }
+        }
+        val targetDt = assignment.target.inferType(program, assignment)
+        val bexpr=assignment.value as? BinaryExpression
+        if(bexpr!=null) {
+            val cv = bexpr.right.constValue(program)?.number?.toDouble()
+            if (cv == null) {
+                if (bexpr.operator == "+" && targetDt != DataType.FLOAT) {
+                    if (bexpr.left isSameAs bexpr.right && assignment.target isSameAs bexpr.left) {
+                        bexpr.operator = "*"
+                        bexpr.right = NumericLiteralValue.optimalInteger(2, assignment.value.position)
+                        optimizationsDone++
+                        return assignment
+                    }
+                }
+            } else {
+                if (assignment.target isSameAs bexpr.left) {
+                    // remove assignments that have no effect  X=X , X+=0, X-=0, X*=1, X/=1, X//=1, A |= 0, A ^= 0, A<<=0, etc etc
+                    // A = A <operator> B
+                    val vardeclDt = (assignment.target.identifier?.targetVarDecl(program.namespace))?.type
+
+                    when (bexpr.operator) {
+                        "+" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                    // replace by several INCs (a bit less when dealing with memory targets)
+                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
+                                    repeat(cv.toInt()) {
+                                        decs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
+                                    }
+                                    return decs
+                                }
+                            }
+                        }
+                        "-" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                    // replace by several DECs (a bit less when dealing with memory targets)
+                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
+                                    repeat(cv.toInt()) {
+                                        decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
+                                    }
+                                    return decs
+                                }
+                            }
+                        }
+                        "*" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "/" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "**" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "|" -> if (cv == 0.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "^" -> if (cv == 0.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "<<" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            }
+                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
+                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
+                                assignment.value = NumericLiteralValue.optimalInteger(0, assignment.value.position)
+                                assignment.value.linkParents(assignment)
+                                optimizationsDone++
+                            } else {
+                                // replace by in-place lsl(...) call
+                                val scope = AnonymousScope(mutableListOf(), assignment.position)
+                                var numshifts = cv.toInt()
+                                while (numshifts > 0) {
+                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position), mutableListOf(bexpr.left), assignment.position))
+                                    numshifts--
+                                }
+                                optimizationsDone++
+                                return scope
+                            }
+                        }
+                        ">>" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            }
+                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
+                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
+                                assignment.value = NumericLiteralValue.optimalInteger(0, assignment.value.position)
+                                assignment.value.linkParents(assignment)
+                                optimizationsDone++
+                            } else {
+                                // replace by in-place lsr(...) call
+                                val scope = AnonymousScope(mutableListOf(), assignment.position)
+                                var numshifts = cv.toInt()
+                                while (numshifts > 0) {
+                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position), mutableListOf(bexpr.left), assignment.position))
+                                    numshifts--
+                                }
+                                optimizationsDone++
+                                return scope
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        return super.visit(assignment)
+    }
+
+    override fun visit(scope: AnonymousScope): Statement {
+        val linesToRemove = deduplicateAssignments(scope.statements)
+        if(linesToRemove.isNotEmpty()) {
+            linesToRemove.reversed().forEach{scope.statements.removeAt(it)}
+        }
+        return super.visit(scope)
+    }
+
+    override fun visit(label: Label): Statement {
+        // remove duplicate labels
+        val stmts = label.definingScope().statements
+        val startIdx = stmts.indexOf(label)
+        if(startIdx<(stmts.size-1) && stmts[startIdx+1] == label)
+            return NopStatement.insteadOf(label)
+
+        return super.visit(label)
+    }
+}
+
+
+
+internal class FlattenAnonymousScopesAndRemoveNops: IAstVisitor {
+    private var scopesToFlatten = mutableListOf<INameScope>()
+    private val nopStatements = mutableListOf<NopStatement>()
+
+    override fun visit(program: Program) {
+        super.visit(program)
+        for(scope in scopesToFlatten.reversed()) {
+            val namescope = scope.parent as INameScope
+            val idx = namescope.statements.indexOf(scope as Statement)
+            if(idx>=0) {
+                val nop = NopStatement.insteadOf(namescope.statements[idx])
+                nop.parent = namescope as Node
+                namescope.statements[idx] = nop
+                namescope.statements.addAll(idx, scope.statements)
+                scope.statements.forEach { it.parent = namescope }
+                visit(nop)
+            }
+        }
+
+        this.nopStatements.forEach {
+            it.definingScope().remove(it)
+        }
+    }
+
+    override fun visit(scope: AnonymousScope) {
+        if(scope.parent is INameScope) {
+            scopesToFlatten.add(scope)  // get rid of the anonymous scope
+        }
+
+        return super.visit(scope)
+    }
+
+    override fun visit(nopStatement: NopStatement) {
+        nopStatements.add(nopStatement)
+    }
+}

compiler/src/prog8/optimizing/ConstExprEvaluator.kt

@@ -1,288 +0,0 @@
-package prog8.optimizing
-
-import prog8.ast.*
-import prog8.compiler.HeapValues
-import kotlin.math.pow
-
-
-val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
-
-
-class ConstExprEvaluator {
-
-    fun evaluate(left: LiteralValue, operator: String, right: LiteralValue, heap: HeapValues): IExpression {
-        return when(operator) {
-            "+" -> plus(left, right, heap)
-            "-" -> minus(left, right)
-            "*" -> multiply(left, right, heap)
-            "/" -> divide(left, right)
-            "%" -> remainder(left, right)
-            "**" -> power(left, right)
-            "&" -> bitwiseand(left, right)
-            "|" -> bitwiseor(left, right)
-            "^" -> bitwisexor(left, right)
-            "and" -> logicaland(left, right)
-            "or" -> logicalor(left, right)
-            "xor" -> logicalxor(left, right)
-            "<" -> LiteralValue.fromBoolean(left < right, left.position)
-            ">" -> LiteralValue.fromBoolean(left > right, left.position)
-            "<=" -> LiteralValue.fromBoolean(left <= right, left.position)
-            ">=" -> LiteralValue.fromBoolean(left >= right, left.position)
-            "==" -> LiteralValue.fromBoolean(left == right, left.position)
-            "!=" -> LiteralValue.fromBoolean(left != right, left.position)
-            "<<" -> shiftedleft(left, right)
-            ">>" -> shiftedright(left, right)
-            else -> throw FatalAstException("const evaluation for invalid operator $operator")
-        }
-    }
-
-    private fun shiftedright(left: LiteralValue, amount: LiteralValue): IExpression {
-        if(left.asIntegerValue==null || amount.asIntegerValue==null)
-            throw ExpressionError("cannot compute $left >> $amount", left.position)
-        val result =
-                if(left.type==DataType.UBYTE || left.type==DataType.UWORD)
-                    left.asIntegerValue.ushr(amount.asIntegerValue)
-                else
-                    left.asIntegerValue.shr(amount.asIntegerValue)
-        return LiteralValue.fromNumber(result, left.type, left.position)
-    }
-
-    private fun shiftedleft(left: LiteralValue, amount: LiteralValue): IExpression {
-        if(left.asIntegerValue==null || amount.asIntegerValue==null)
-            throw ExpressionError("cannot compute $left << $amount", left.position)
-        val result = left.asIntegerValue.shl(amount.asIntegerValue)
-        return LiteralValue.fromNumber(result, left.type, left.position)
-    }
-
-    private fun logicalxor(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot compute $left locical-bitxor $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean((left.asIntegerValue != 0) xor (right.asIntegerValue != 0), left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean((left.asIntegerValue != 0) xor (right.floatvalue != 0.0), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean((left.floatvalue != 0.0) xor (right.asIntegerValue != 0), left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean((left.floatvalue != 0.0) xor (right.floatvalue != 0.0), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun logicalor(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot compute $left locical-or $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean(left.asIntegerValue != 0 || right.asIntegerValue != 0, left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean(left.asIntegerValue != 0 || right.floatvalue != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean(left.floatvalue != 0.0 || right.asIntegerValue != 0, left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean(left.floatvalue != 0.0 || right.floatvalue != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun logicaland(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot compute $left locical-and $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean(left.asIntegerValue != 0 && right.asIntegerValue != 0, left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean(left.asIntegerValue != 0 && right.floatvalue != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.fromBoolean(left.floatvalue != 0.0 && right.asIntegerValue != 0, left.position)
-                right.floatvalue!=null -> LiteralValue.fromBoolean(left.floatvalue != 0.0 && right.floatvalue != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun bitwisexor(left: LiteralValue, right: LiteralValue): LiteralValue {
-        if(left.type== DataType.UBYTE) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UBYTE, bytevalue = (left.bytevalue!!.toInt() xor (right.asIntegerValue and 255)).toShort(), position = left.position)
-            }
-        } else if(left.type== DataType.UWORD) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UWORD, wordvalue = left.wordvalue!! xor right.asIntegerValue, position = left.position)
-            }
-        }
-        throw ExpressionError("cannot calculate $left ^ $right", left.position)
-    }
-
-    private fun bitwiseor(left: LiteralValue, right: LiteralValue): LiteralValue {
-        if(left.type== DataType.UBYTE) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UBYTE, bytevalue = (left.bytevalue!!.toInt() or (right.asIntegerValue and 255)).toShort(), position = left.position)
-            }
-        } else if(left.type== DataType.UWORD) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UWORD, wordvalue = left.wordvalue!! or right.asIntegerValue, position = left.position)
-            }
-        }
-        throw ExpressionError("cannot calculate $left | $right", left.position)
-    }
-
-    private fun bitwiseand(left: LiteralValue, right: LiteralValue): LiteralValue {
-        if(left.type== DataType.UBYTE) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UBYTE, bytevalue = (left.bytevalue!!.toInt() or (right.asIntegerValue and 255)).toShort(), position = left.position)
-            }
-        } else if(left.type== DataType.UWORD) {
-            if(right.asIntegerValue!=null) {
-                return LiteralValue(DataType.UWORD, wordvalue = left.wordvalue!! or right.asIntegerValue, position = left.position)
-            }
-        }
-        throw ExpressionError("cannot calculate $left & $right", left.position)
-    }
-
-    private fun power(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot calculate $left ** $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.optimalNumeric(left.asIntegerValue.toDouble().pow(right.asIntegerValue), left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue.toDouble().pow(right.floatvalue), position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue.pow(right.asIntegerValue), position = left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue.pow(right.floatvalue), position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun plus(left: LiteralValue, right: LiteralValue, heap: HeapValues): LiteralValue {
-        val error = "cannot add $left and $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.optimalNumeric(left.asIntegerValue + right.asIntegerValue, left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue + right.floatvalue, position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue + right.asIntegerValue, position = left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue + right.floatvalue, position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.isString -> when {
-                right.isString -> {
-                    val newStr = left.strvalue(heap) + right.strvalue(heap)
-                    if(newStr.length > 255) throw ExpressionError("string too long", left.position)
-                    LiteralValue(DataType.STR, strvalue = newStr, position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun minus(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot subtract $left and $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.optimalNumeric(left.asIntegerValue - right.asIntegerValue, left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue - right.floatvalue, position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue - right.asIntegerValue, position = left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue - right.floatvalue, position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun multiply(left: LiteralValue, right: LiteralValue, heap: HeapValues): LiteralValue {
-        val error = "cannot multiply ${left.type} and ${right.type}"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue.optimalNumeric(left.asIntegerValue * right.asIntegerValue, left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue * right.floatvalue, position = left.position)
-                right.isString -> {
-                    if(right.strvalue(heap).length * left.asIntegerValue > 255) throw ExpressionError("string too long", left.position)
-                    LiteralValue(DataType.STR, strvalue = right.strvalue(heap).repeat(left.asIntegerValue), position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue * right.asIntegerValue, position = left.position)
-                right.floatvalue!=null -> LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue * right.floatvalue, position = left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun divideByZeroError(pos: Position): Unit =
-            throw ExpressionError("division by zero", pos)
-
-    private fun divide(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot divide $left by $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> {
-                    if(right.asIntegerValue==0) divideByZeroError(right.position)
-                    val result: Int = left.asIntegerValue / right.asIntegerValue
-                    LiteralValue.optimalNumeric(result, left.position)
-                }
-                right.floatvalue!=null -> {
-                    if(right.floatvalue==0.0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue / right.floatvalue, position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> {
-                    if(right.asIntegerValue==0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue / right.asIntegerValue, position = left.position)
-                }
-                right.floatvalue!=null -> {
-                    if(right.floatvalue==0.0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue / right.floatvalue, position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun remainder(left: LiteralValue, right: LiteralValue): LiteralValue {
-        val error = "cannot compute remainder of $left by $right"
-        return when {
-            left.asIntegerValue!=null -> when {
-                right.asIntegerValue!=null -> {
-                    if(right.asIntegerValue==0) divideByZeroError(right.position)
-                    LiteralValue.optimalNumeric(left.asIntegerValue.toDouble() % right.asIntegerValue.toDouble(), left.position)
-                }
-                right.floatvalue!=null -> {
-                    if(right.floatvalue==0.0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.asIntegerValue % right.floatvalue, position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            left.floatvalue!=null -> when {
-                right.asIntegerValue!=null -> {
-                    if(right.asIntegerValue==0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue % right.asIntegerValue, position = left.position)
-                }
-                right.floatvalue!=null -> {
-                    if(right.floatvalue==0.0) divideByZeroError(right.position)
-                    LiteralValue(DataType.FLOAT, floatvalue = left.floatvalue % right.floatvalue, position = left.position)
-                }
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-}

compiler/src/prog8/optimizing/Extensions.kt

@@ -1,48 +0,0 @@
-package prog8.optimizing
-
-import prog8.ast.AstException
-import prog8.ast.INameScope
-import prog8.ast.Module
-import prog8.compiler.HeapValues
-import prog8.parser.ParsingFailedError
-
-
-fun Module.constantFold(globalNamespace: INameScope, heap: HeapValues) {
-    val optimizer = ConstantFolding(globalNamespace, heap)
-    try {
-        this.process(optimizer)
-    } catch (ax: AstException) {
-        optimizer.addError(ax)
-    }
-
-    while(optimizer.errors.isEmpty() && optimizer.optimizationsDone>0) {
-        optimizer.optimizationsDone = 0
-        this.process(optimizer)
-    }
-
-    if(optimizer.errors.isNotEmpty()) {
-        optimizer.errors.forEach { System.err.println(it) }
-        throw ParsingFailedError("There are ${optimizer.errors.size} errors.")
-    } else {
-        this.linkParents()  // re-link in final configuration
-    }
-}
-
-
-fun Module.optimizeStatements(globalNamespace: INameScope, heap: HeapValues): Int {
-    val optimizer = StatementOptimizer(globalNamespace, heap)
-    this.process(optimizer)
-    for(stmt in optimizer.statementsToRemove) {
-        val scope=stmt.definingScope()
-        scope.remove(stmt)
-    }
-    this.linkParents()  // re-link in final configuration
-
-    return optimizer.optimizationsDone
-}
-
-fun Module.simplifyExpressions(namespace: INameScope, heap: HeapValues) : Int {
-    val optimizer = SimplifyExpressions(namespace, heap)
-    this.process(optimizer)
-    return optimizer.optimizationsDone
-}

compiler/src/prog8/optimizing/StatementOptimizer.kt

@@ -1,556 +0,0 @@
-package prog8.optimizing
-
-import prog8.ast.*
-import prog8.compiler.HeapValues
-import prog8.compiler.target.c64.Petscii
-import prog8.functions.BuiltinFunctions
-import kotlin.math.floor
-
-
-/*
-    todo: subroutines with 1 or 2 byte args or 1 word arg can be converted to asm sub calling convention (args in registers)
-
-
-    todo: implement usage counters for blocks, variables, subroutines, heap variables. Then:
-        todo remove unused blocks
-        todo remove unused variables
-        todo remove unused subroutines
-        todo remove unused strings and arrays from the heap
-        todo inline subroutines that are called exactly once (regardless of their size)
-        todo inline subroutines that are only called a few times (max 3?)
-        todo inline subroutines that are "sufficiently small" (0-3 statements)
-
-    todo analyse for unreachable code and remove that (f.i. code after goto or return that has no label so can never be jumped to)
-*/
-
-class StatementOptimizer(private val namespace: INameScope, private val heap: HeapValues) : IAstProcessor {
-    var optimizationsDone: Int = 0
-        private set
-    var statementsToRemove = mutableListOf<IStatement>()
-        private set
-    private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
-
-    override fun process(block: Block): IStatement {
-        if(block.statements.isEmpty()) {
-            // remove empty block
-            optimizationsDone++
-            statementsToRemove.add(block)
-        }
-        return super.process(block)
-    }
-
-    override fun process(subroutine: Subroutine): IStatement {
-        super.process(subroutine)
-
-        if(subroutine.asmAddress==null) {
-            if(subroutine.statements.isEmpty()) {
-                // remove empty subroutine
-                optimizationsDone++
-                statementsToRemove.add(subroutine)
-            }
-        }
-
-        val linesToRemove = deduplicateAssignments(subroutine.statements)
-        if(linesToRemove.isNotEmpty()) {
-            linesToRemove.reversed().forEach{subroutine.statements.removeAt(it)}
-        }
-
-        if(subroutine.canBeAsmSubroutine) {
-            optimizationsDone++
-            return subroutine.intoAsmSubroutine()   // TODO this doesn't work yet due to parameter vardecl issue
-
-            // TODO fix parameter passing so this also works:
-//            asmsub aa(byte arg @ Y) -> clobbers() -> () {
-//                byte local = arg            ; @todo fix 'undefined symbol arg' by some sort of alias name for the parameter
-//                A=44
-//            }
-
-        }
-
-        return subroutine
-    }
-
-    private fun deduplicateAssignments(statements: List<IStatement>): MutableList<Int> {
-        // removes 'duplicate' assignments that assign the same target
-        val linesToRemove = mutableListOf<Int>()
-        var previousAssignmentLine: Int? = null
-        for (i in 0 until statements.size) {
-            val stmt = statements[i] as? Assignment
-            if (stmt != null && stmt.value is LiteralValue) {
-                if (previousAssignmentLine == null) {
-                    previousAssignmentLine = i
-                    continue
-                } else {
-                    val prev = statements[previousAssignmentLine] as Assignment
-                    if (prev.targets.size == 1 && stmt.targets.size == 1 && same(prev.targets[0], stmt.targets[0])) {
-                        // get rid of the previous assignment, if the target is not MEMORY
-                        if (isNotMemory(prev.targets[0]))
-                            linesToRemove.add(previousAssignmentLine)
-                    }
-                    previousAssignmentLine = i
-                }
-            } else
-                previousAssignmentLine = null
-        }
-        return linesToRemove
-    }
-
-    private fun isNotMemory(target: AssignTarget): Boolean {
-        if(target.register!=null)
-            return true
-        if(target.memoryAddress!=null)
-            return false
-        if(target.arrayindexed!=null) {
-            val targetStmt = target.arrayindexed.identifier.targetVarDecl(namespace)
-            if(targetStmt!=null)
-                return targetStmt.type!=VarDeclType.MEMORY
-        }
-        if(target.identifier!=null) {
-            val targetStmt = target.identifier.targetVarDecl(namespace)
-            if(targetStmt!=null)
-                return targetStmt.type!=VarDeclType.MEMORY
-        }
-        return false
-    }
-
-
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
-            val functionName = functionCallStatement.target.nameInSource[0]
-            if (functionName in pureBuiltinFunctions) {
-                printWarning("statement has no effect (function return value is discarded)", functionCallStatement.position)
-                statementsToRemove.add(functionCallStatement)
-                return functionCallStatement
-            }
-        }
-
-        if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") ||
-                functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) {
-            // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
-            if(functionCallStatement.arglist.single() is LiteralValue)
-                throw AstException("string argument should be on heap already")
-            val stringVar = functionCallStatement.arglist.single() as? IdentifierReference
-            if(stringVar!=null) {
-                val heapId = stringVar.heapId(namespace)
-                val string = heap.get(heapId).str!!
-                if(string.length==1) {
-                    val petscii = Petscii.encodePetscii(string, true)[0]
-                    functionCallStatement.arglist.clear()
-                    functionCallStatement.arglist.add(LiteralValue.optimalInteger(petscii, functionCallStatement.position))
-                    functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
-                    optimizationsDone++
-                    return functionCallStatement
-                } else if(string.length==2) {
-                    val petscii = Petscii.encodePetscii(string, true)
-                    val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(LiteralValue.optimalInteger(petscii[0], functionCallStatement.position)), functionCallStatement.position))
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(LiteralValue.optimalInteger(petscii[1], functionCallStatement.position)), functionCallStatement.position))
-                    optimizationsDone++
-                    return scope
-                }
-            }
-        }
-
-        // if it calls a subroutine,
-        // and the first instruction in the subroutine is a jump, call that jump target instead
-        // if the first instruction in the subroutine is a return statement, replace with a nop instruction
-        val subroutine = functionCallStatement.target.targetSubroutine(namespace)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump && first.identifier!=null) {
-                optimizationsDone++
-                return FunctionCallStatement(first.identifier, functionCallStatement.arglist, functionCallStatement.position)
-            }
-            if(first is ReturnFromIrq || first is Return) {
-                optimizationsDone++
-                return NopStatement(functionCallStatement.position)
-            }
-        }
-
-        return super.process(functionCallStatement)
-    }
-
-    override fun process(functionCall: FunctionCall): IExpression {
-        // if it calls a subroutine,
-        // and the first instruction in the subroutine is a jump, call that jump target instead
-        // if the first instruction in the subroutine is a return statement with constant value, replace with the constant value
-        val subroutine = functionCall.target.targetSubroutine(namespace)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump && first.identifier!=null) {
-                optimizationsDone++
-                return FunctionCall(first.identifier, functionCall.arglist, functionCall.position)
-            }
-            if(first is Return && first.values.size==1) {
-                val constval = first.values[0].constValue(namespace, heap)
-                if(constval!=null)
-                    return constval
-            }
-        }
-        return super.process(functionCall)
-    }
-
-    override fun process(ifStatement: IfStatement): IStatement {
-        super.process(ifStatement)
-
-        if(ifStatement.truepart.isEmpty() && ifStatement.elsepart.isEmpty()) {
-            statementsToRemove.add(ifStatement)
-            optimizationsDone++
-            return ifStatement
-        }
-
-        if(ifStatement.truepart.isEmpty() && ifStatement.elsepart.isNotEmpty()) {
-            // invert the condition and move else part to true part
-            ifStatement.truepart = ifStatement.elsepart
-            ifStatement.elsepart = AnonymousScope(mutableListOf(), ifStatement.elsepart.position)
-            ifStatement.condition = PrefixExpression("not", ifStatement.condition, ifStatement.condition.position)
-            optimizationsDone++
-            return ifStatement
-        }
-
-        val constvalue = ifStatement.condition.constValue(namespace, heap)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> keep only if-part
-                printWarning("condition is always true", ifStatement.position)
-                optimizationsDone++
-                ifStatement.truepart
-            } else {
-                // always false -> keep only else-part
-                printWarning("condition is always false", ifStatement.position)
-                optimizationsDone++
-                ifStatement.elsepart
-            }
-        }
-        return ifStatement
-    }
-
-    override fun process(forLoop: ForLoop): IStatement {
-        super.process(forLoop)
-        if(forLoop.body.isEmpty()) {
-            // remove empty for loop
-            statementsToRemove.add(forLoop)
-            optimizationsDone++
-            return forLoop
-        } else if(forLoop.body.statements.size==1) {
-            val loopvar = forLoop.body.statements[0] as? VarDecl
-            if(loopvar!=null && loopvar.name==forLoop.loopVar?.nameInSource?.singleOrNull()) {
-                // remove empty for loop
-                statementsToRemove.add(forLoop)
-                optimizationsDone++
-                return forLoop
-            }
-        }
-
-
-        val range = forLoop.iterable as? RangeExpr
-        if(range!=null) {
-            if(range.size(heap)==1) {
-                // for loop over a (constant) range of just a single value-- optimize the loop away
-                // loopvar/reg = range value , follow by block
-                val assignment = Assignment(listOf(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, null, forLoop.position)), null, range.from, forLoop.position)
-                forLoop.body.statements.add(0, assignment)
-                optimizationsDone++
-                return forLoop.body
-            }
-        }
-        return forLoop
-    }
-
-    override fun process(whileLoop: WhileLoop): IStatement {
-        super.process(whileLoop)
-        val constvalue = whileLoop.condition.constValue(namespace, heap)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> print a warning, and optimize into body + jump (if there are no continue and break statements)
-                printWarning("condition is always true", whileLoop.position)
-                if(hasContinueOrBreak(whileLoop.body))
-                    return whileLoop
-                val label = Label("__back", whileLoop.condition.position)
-                whileLoop.body.statements.add(0, label)
-                whileLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf("__back"), whileLoop.condition.position),
-                        null, whileLoop.condition.position))
-                optimizationsDone++
-                return whileLoop.body
-            } else {
-                // always false -> ditch whole statement
-                printWarning("condition is always false", whileLoop.position)
-                optimizationsDone++
-                NopStatement(whileLoop.position)
-            }
-        }
-        return whileLoop
-    }
-
-    override fun process(repeatLoop: RepeatLoop): IStatement {
-        super.process(repeatLoop)
-        val constvalue = repeatLoop.untilCondition.constValue(namespace, heap)
-        if(constvalue!=null) {
-            return if(constvalue.asBooleanValue){
-                // always true -> keep only the statement block (if there are no continue and break statements)
-                printWarning("condition is always true", repeatLoop.position)
-                if(hasContinueOrBreak(repeatLoop.body))
-                    repeatLoop
-                else {
-                    optimizationsDone++
-                    repeatLoop.body
-                }
-            } else {
-                // always false -> print a warning, and optimize into body + jump (if there are no continue and break statements)
-                printWarning("condition is always false", repeatLoop.position)
-                if(hasContinueOrBreak(repeatLoop.body))
-                    return repeatLoop
-                val label = Label("__back", repeatLoop.untilCondition.position)
-                repeatLoop.body.statements.add(0, label)
-                repeatLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf("__back"), repeatLoop.untilCondition.position),
-                        null, repeatLoop.untilCondition.position))
-                optimizationsDone++
-                return repeatLoop.body
-            }
-        }
-        return repeatLoop
-    }
-
-    private fun hasContinueOrBreak(scope: INameScope): Boolean {
-
-        class Searcher:IAstProcessor
-        {
-            var count=0
-
-            override fun process(breakStmt: Break): IStatement {
-                count++
-                return super.process(breakStmt)
-            }
-
-            override fun process(contStmt: Continue): IStatement {
-                count++
-                return super.process(contStmt)
-            }
-        }
-        val s=Searcher()
-        for(stmt in scope.statements) {
-            stmt.process(s)
-            if(s.count>0)
-                return true
-        }
-        return s.count > 0
-    }
-
-    override fun process(jump: Jump): IStatement {
-        val subroutine = jump.identifier?.targetSubroutine(namespace)
-        if(subroutine!=null) {
-            // if the first instruction in the subroutine is another jump, shortcut this one
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Jump) {
-                optimizationsDone++
-                return first
-            }
-        }
-        return jump
-    }
-
-    override fun process(assignment: Assignment): IStatement {
-        if(assignment.aug_op!=null)
-            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
-
-        if(assignment.targets.size==1) {
-            val target=assignment.targets[0]
-            if(same(target, assignment.value)) {
-                optimizationsDone++
-                return NopStatement(assignment.position)
-            }
-            val targetDt = target.determineDatatype(namespace, heap, assignment)!!
-            val bexpr=assignment.value as? BinaryExpression
-            if(bexpr!=null) {
-                val cv = bexpr.right.constValue(namespace, heap)?.asNumericValue?.toDouble()
-                if(cv==null) {
-                    if(bexpr.operator=="+" && targetDt!=DataType.FLOAT) {
-                        if (same(bexpr.left, bexpr.right) && same(target, bexpr.left)) {
-                            bexpr.operator = "*"
-                            bexpr.right = LiteralValue.optimalInteger(2, assignment.value.position)
-                            optimizationsDone++
-                            return assignment
-                        }
-                    }
-                } else {
-                    if (same(target, bexpr.left)) {
-                        // remove assignments that have no effect  X=X , X+=0, X-=0, X*=1, X/=1, X//=1, A |= 0, A ^= 0, A<<=0, etc etc
-                        // A = A <operator> B
-                        val vardeclDt = (target.identifier?.targetVarDecl(namespace))?.type
-
-                        when (bexpr.operator) {
-                            "+" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                    if((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt!=VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                        // replace by several INCs (a bit less when dealing with memory targets)
-                                        val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                        repeat(cv.toInt()) {
-                                            decs.statements.add(PostIncrDecr(target, "++", assignment.position))
-                                        }
-                                        return decs
-                                    }
-                                }
-                            }
-                            "-" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                    if((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt!=VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                        // replace by several DECs (a bit less when dealing with memory targets)
-                                        val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                        repeat(cv.toInt()) {
-                                            decs.statements.add(PostIncrDecr(target, "--", assignment.position))
-                                        }
-                                        return decs
-                                    }
-                                }
-                            }
-                            "*" -> if (cv == 1.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "/" -> if (cv == 1.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "**" -> if (cv == 1.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "|" -> if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "^" -> if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "<<" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                }
-                                if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                        ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
-                                    assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
-                                    assignment.value.linkParents(assignment)
-                                    optimizationsDone++
-                                } else {
-                                    // replace by in-place lsl(...) call
-                                    val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                    var numshifts = cv.toInt()
-                                    while (numshifts > 0) {
-                                        scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position), mutableListOf(bexpr.left), assignment.position))
-                                        numshifts--
-                                    }
-                                    optimizationsDone++
-                                    return scope
-                                }
-                            }
-                            ">>" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                }
-                                if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                        ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
-                                    assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
-                                    assignment.value.linkParents(assignment)
-                                    optimizationsDone++
-                                } else {
-                                    // replace by in-place lsr(...) call
-                                    val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                    var numshifts = cv.toInt()
-                                    while (numshifts > 0) {
-                                        scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position), mutableListOf(bexpr.left), assignment.position))
-                                        numshifts--
-                                    }
-                                    optimizationsDone++
-                                    return scope
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        return super.process(assignment)
-    }
-
-    override fun process(scope: AnonymousScope): AnonymousScope {
-        val linesToRemove = deduplicateAssignments(scope.statements)
-        if(linesToRemove.isNotEmpty()) {
-            linesToRemove.reversed().forEach{scope.statements.removeAt(it)}
-        }
-        return super.process(scope)
-    }
-
-    private fun same(target: AssignTarget, value: IExpression): Boolean {
-        return when {
-            target.memoryAddress!=null -> false
-            target.register!=null -> value is RegisterExpr && value.register==target.register
-            target.identifier!=null -> value is IdentifierReference && value.nameInSource==target.identifier.nameInSource
-            target.arrayindexed!=null -> value is ArrayIndexedExpression &&
-                    value.identifier.nameInSource==target.arrayindexed.identifier.nameInSource &&
-                    value.arrayspec.size()!=null &&
-                    target.arrayindexed.arrayspec.size()!=null &&
-                    value.arrayspec.size()==target.arrayindexed.arrayspec.size()
-            else -> false
-        }
-    }
-
-    private fun same(target1: AssignTarget, target2: AssignTarget): Boolean {
-        if(target1===target2)
-            return true
-        if(target1.register!=null && target2.register!=null)
-            return target1.register==target2.register
-        if(target1.identifier!=null && target2.identifier!=null)
-            return target1.identifier.nameInSource==target2.identifier.nameInSource
-        if(target1.memoryAddress!=null && target2.memoryAddress!=null) {
-            val addr1 = target1.memoryAddress!!.addressExpression.constValue(namespace, heap)
-            val addr2 = target2.memoryAddress!!.addressExpression.constValue(namespace, heap)
-            return addr1!=null && addr2!=null && addr1==addr2
-        }
-        if(target1.arrayindexed!=null && target2.arrayindexed!=null) {
-            if(target1.arrayindexed.identifier.nameInSource == target2.arrayindexed.identifier.nameInSource) {
-                val x1 = target1.arrayindexed.arrayspec.index.constValue(namespace, heap)
-                val x2 = target2.arrayindexed.arrayspec.index.constValue(namespace, heap)
-                return x1!=null && x2!=null && x1==x2
-            }
-        }
-        return false
-    }
-}
-
-
-fun same(left: IExpression, right: IExpression): Boolean {
-    if(left===right)
-        return true
-    when(left) {
-        is RegisterExpr ->
-            return (right is RegisterExpr && right.register==left.register)
-        is IdentifierReference ->
-            return (right is IdentifierReference && right.nameInSource==left.nameInSource)
-        is PrefixExpression ->
-            return (right is PrefixExpression && right.operator==left.operator && same(right.expression, left.expression))
-        is BinaryExpression ->
-            return (right is BinaryExpression && right.operator==left.operator
-                    && same(right.left, left.left)
-                    && same(right.right, left.right))
-        is ArrayIndexedExpression -> {
-            return (right is ArrayIndexedExpression && right.identifier.nameInSource == left.identifier.nameInSource
-                    && same(right.arrayspec.index, left.arrayspec.index))
-        }
-        is LiteralValue -> return (right is LiteralValue && right==left)
-    }
-    return false
-}

compiler/src/prog8/parser/CommentHandlingTokenStream.kt

@@ -4,7 +4,7 @@ import org.antlr.v4.runtime.CommonTokenStream
 import org.antlr.v4.runtime.Lexer
 
 
-class CommentHandlingTokenStream(lexer: Lexer) : CommonTokenStream(lexer) {
+internal class CommentHandlingTokenStream(lexer: Lexer) : CommonTokenStream(lexer) {
 
     data class Comment(val type: String, val line: Int, val comment: String)
 

compiler/src/prog8/parser/ModuleParsing.kt

@@ -1,21 +1,21 @@
 package prog8.parser
 
 import org.antlr.v4.runtime.*
-import prog8.ast.*
-import prog8.compiler.LauncherType
-import prog8.compiler.OutputType
-import prog8.determineCompilationOptions
+import prog8.ast.Module
+import prog8.ast.Program
+import prog8.ast.antlr.toAst
+import prog8.ast.base.Position
+import prog8.ast.base.SyntaxError
+import prog8.ast.base.checkImportedValid
+import prog8.ast.statements.Directive
+import prog8.ast.statements.DirectiveArg
 import java.io.InputStream
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
-import java.util.*
 
 
-class ParsingFailedError(override var message: String) : Exception(message)
-
-
-private val importedModules : HashMap<String, Module> = hashMapOf()
+internal class ParsingFailedError(override var message: String) : Exception(message)
 
 
 private class LexerErrorListener: BaseErrorListener() {
@@ -29,8 +29,36 @@ private class LexerErrorListener: BaseErrorListener() {
 internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexer(input)
 
 
-fun importModule(stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
-    val moduleName = modulePath.fileName
+internal fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
+
+
+internal fun importModule(program: Program, filePath: Path): Module {
+    print("importing '${moduleName(filePath.fileName)}'")
+    if(filePath.parent!=null) {
+        var importloc = filePath.toString()
+        val curdir = Paths.get("").toAbsolutePath().toString()
+        if(importloc.startsWith(curdir))
+            importloc = "." + importloc.substring(curdir.length)
+        println(" (from '$importloc')")
+    }
+    else
+        println("")
+    if(!Files.isReadable(filePath))
+        throw ParsingFailedError("No such file: $filePath")
+
+    val input = CharStreams.fromPath(filePath)
+    return importModule(program, input, filePath, false)
+}
+
+internal fun importLibraryModule(program: Program, name: String): Module? {
+    val import = Directive("%import", listOf(
+            DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
+    ), Position("<<<implicit-import>>>", 0, 0, 0))
+    return executeImportDirective(program, import, Paths.get(""))
+}
+
+internal fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
+    val moduleName = moduleName(modulePath.fileName)
     val lexer = CustomLexer(modulePath, stream)
     val lexerErrors = LexerErrorListener()
     lexer.addErrorListener(lexerErrors)
@@ -45,68 +73,25 @@ fun importModule(stream: CharStream, modulePath: Path, isLibrary: Boolean): Modu
     // tokens.commentTokens().forEach { println(it) }
 
     // convert to Ast
-    val moduleAst = parseTree.toAst(moduleName.toString(), isLibrary, modulePath)
-    importedModules[moduleAst.name] = moduleAst
+    val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath)
+    moduleAst.program = program
+    moduleAst.linkParents(program.namespace)
+    program.modules.add(moduleAst)
 
-    // process imports
+    // accept additional imports
     val lines = moduleAst.statements.toMutableList()
-    if(!moduleAst.position.file.startsWith("c64utils.") && !moduleAst.isLibraryModule) {
-        // if the output is a PRG or BASIC program, include the c64utils library
-        val compilerOptions = determineCompilationOptions(moduleAst)
-        if(compilerOptions.launcher==LauncherType.BASIC || compilerOptions.output==OutputType.PRG) {
-            lines.add(0, Directive("%import", listOf(DirectiveArg(null, "c64utils", null, moduleAst.position)), moduleAst.position))
-        }
-    }
-    // always import the prog8lib and math compiler libraries
-    if(!moduleAst.position.file.startsWith("math."))
-        lines.add(0, Directive("%import", listOf(DirectiveArg(null, "math", null, moduleAst.position)), moduleAst.position))
-    if(!moduleAst.position.file.startsWith("prog8lib."))
-        lines.add(0, Directive("%import", listOf(DirectiveArg(null, "prog8lib", null, moduleAst.position)), moduleAst.position))
-
-    val imports = lines
-            .asSequence()
-            .mapIndexed { i, it -> Pair(i, it) }
-            .filter { (it.second as? Directive)?.directive == "%import" }
-            .map { Pair(it.first, executeImportDirective(it.second as Directive, modulePath)) }
-            .toList()
-
-    imports.reversed().forEach {
-        if(it.second==null) {
-            // this import was already satisfied. just remove this line.
-            lines.removeAt(it.first)
-        } else {
-            // merge imported lines at this spot
-            lines.addAll(it.first, it.second!!.statements)
-        }
-    }
+    lines.asSequence()
+         .mapIndexed { i, it -> Pair(i, it) }
+         .filter { (it.second as? Directive)?.directive == "%import" }
+         .forEach { executeImportDirective(program, it.second as Directive, modulePath) }
 
     moduleAst.statements = lines
     return moduleAst
 }
 
-
-fun importModule(filePath: Path) : Module {
-    print("importing '${filePath.fileName}'")
-    if(filePath.parent!=null) {
-        var importloc = filePath.toString()
-        val curdir = Paths.get("").toAbsolutePath().toString()
-        if(importloc.startsWith(curdir))
-            importloc = "." + importloc.substring(curdir.length)
-        println(" (from '$importloc')")
-    }
-    else
-        println("")
-    if(!Files.isReadable(filePath))
-        throw ParsingFailedError("No such file: $filePath")
-
-    val input = CharStreams.fromPath(filePath)
-    return importModule(input, filePath, filePath.parent==null)
-}
-
-
-private fun discoverImportedModuleFile(name: String, importedFrom: Path, position: Position?): Path {
+private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
     val fileName = "$name.p8"
-    val locations = mutableListOf(Paths.get(importedFrom.parent.toString()))
+    val locations = mutableListOf(Paths.get(source.parent.toString()))
 
     val propPath = System.getProperty("prog8.libdir")
     if(propPath!=null)
@@ -124,13 +109,15 @@ private fun discoverImportedModuleFile(name: String, importedFrom: Path, positio
     throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: $locations)")
 }
 
-private fun executeImportDirective(import: Directive, importedFrom: Path): Module? {
+private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
     if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
         throw SyntaxError("invalid import directive", import.position)
     val moduleName = import.args[0].name!!
     if("$moduleName.p8" == import.position.file)
         throw SyntaxError("cannot import self", import.position)
-    if(importedModules.containsKey(moduleName))
+
+    val existing = program.modules.singleOrNull { it.name == moduleName }
+    if(existing!=null)
         return null
 
     val resource = tryGetEmbeddedResource(moduleName+".p8")
@@ -138,18 +125,21 @@ private fun executeImportDirective(import: Directive, importedFrom: Path): Modul
         if(resource!=null) {
             // load the module from the embedded resource
             resource.use {
-                println("importing '$moduleName' (embedded library)")
-                importModule(CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
+                if(import.args[0].int==42)
+                    println("importing '$moduleName' (library, auto)")
+                else
+                    println("importing '$moduleName' (library)")
+                importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
             }
         } else {
-            val modulePath = discoverImportedModuleFile(moduleName, importedFrom, import.position)
-            importModule(modulePath)
+            val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
+            importModule(program, modulePath)
         }
 
     importedModule.checkImportedValid()
     return importedModule
 }
 
-fun tryGetEmbeddedResource(name: String): InputStream? {
+internal fun tryGetEmbeddedResource(name: String): InputStream? {
     return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
 }

compiler/src/prog8/stackvm/Memory.kt

@@ -1,102 +0,0 @@
-package prog8.stackvm
-
-import prog8.compiler.target.c64.Mflpt5
-import prog8.compiler.target.c64.Petscii
-import kotlin.math.abs
-
-class Memory {
-    private val mem = ShortArray(65536)         // shorts because byte is signed and we store values 0..255
-
-    fun getUByte(address: Int): Short {
-        return mem[address]
-    }
-
-    fun getSByte(address: Int): Short {
-        val ubyte = getUByte(address)
-        if(ubyte <= 127)
-            return ubyte
-        return (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
-    }
-
-    fun setUByte(address: Int, value: Short) {
-        if(value !in 0..255)
-            throw VmExecutionException("ubyte value out of range")
-        mem[address] = value
-    }
-
-    fun setSByte(address: Int, value: Short) {
-        if(value !in -128..127) throw VmExecutionException("byte value out of range")
-        if(value>=0)
-            mem[address] = value
-        else
-            mem[address] = ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
-    }
-
-    fun getUWord(address: Int): Int {
-        return mem[address] + 256*mem[address+1]
-    }
-
-    fun getSWord(address: Int): Int {
-        val uword = getUWord(address)
-        if(uword <= 32767)
-            return uword
-        return -((uword xor 65535)+1)   // 2's complement
-    }
-
-    fun setUWord(address: Int, value: Int) {
-        if(value !in 0..65535)
-            throw VmExecutionException("uword value out of range")
-        mem[address] = value.and(255).toShort()
-        mem[address+1] = (value / 256).toShort()
-    }
-
-    fun setSWord(address: Int, value: Int) {
-        if(value !in -32768..32767) throw VmExecutionException("word value out of range")
-        if(value>=0)
-            setUWord(address, value)
-        else
-            setUWord(address, (abs(value) xor 65535)+1)        // 2's complement
-    }
-
-    fun setFloat(address: Int, value: Double) {
-        val mflpt5 = Mflpt5.fromNumber(value)
-        mem[address] = mflpt5.b0
-        mem[address+1] = mflpt5.b1
-        mem[address+2] = mflpt5.b2
-        mem[address+3] = mflpt5.b3
-        mem[address+4] = mflpt5.b4
-    }
-
-    fun getFloat(address: Int): Double {
-        return Mflpt5(mem[address], mem[address + 1], mem[address + 2], mem[address + 3], mem[address + 4]).toDouble()
-    }
-
-    fun setString(address: Int, str: String) {
-        // lowercase PETSCII
-        val petscii = Petscii.encodePetscii(str, true)
-        var addr = address
-        for (c in petscii) mem[addr++] = c
-        mem[addr] = 0
-    }
-
-    fun getString(strAddress: Int): String {
-        // lowercase PETSCII
-        val petscii = mutableListOf<Short>()
-        var addr = strAddress
-        while(true) {
-            val byte = mem[addr++]
-            if(byte==0.toShort()) break
-            petscii.add(byte)
-        }
-        return Petscii.decodePetscii(petscii, true)
-    }
-
-    fun clear() {
-        for(i in 0..65535) mem[i]=0
-    }
-
-    fun copy(from: Int, to: Int, numbytes: Int) {
-        for(i in 0 until numbytes)
-            mem[to+i] = mem[from+i]
-    }
-}

compiler/src/prog8/vm/RuntimeValue.kt

@@ -0,0 +1,633 @@
+package prog8.vm
+
+import prog8.ast.base.*
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.compiler.HeapValues
+import prog8.compiler.target.c64.Petscii
+import kotlin.math.abs
+import kotlin.math.pow
+
+
+/**
+ * Rather than a literal value (NumericLiteralValue) that occurs in the parsed source code,
+ * this runtime value can be used to *execute* the parsed Ast (or another intermediary form)
+ * It contains a value of a variable during run time of the program and provides arithmetic operations on the value.
+ */
+open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=null,
+                        val array: Array<Number>?=null, val heapId: Int?=null) {
+
+    val byteval: Short?
+    val wordval: Int?
+    val floatval: Double?
+    val asBoolean: Boolean
+
+    companion object {
+        fun fromLv(literalValue: NumericLiteralValue): RuntimeValue {
+            return RuntimeValue(literalValue.type, num = literalValue.number)
+        }
+
+        fun fromLv(literalValue: ReferenceLiteralValue, heap: HeapValues): RuntimeValue {
+            return when(literalValue.type) {
+                in StringDatatypes -> fromHeapId(literalValue.heapId!!, heap)
+                in ArrayDatatypes -> fromHeapId(literalValue.heapId!!, heap)
+                else -> throw IllegalArgumentException("weird source value $literalValue")
+            }
+        }
+
+        fun fromHeapId(heapId: Int, heap: HeapValues): RuntimeValue {
+            val value = heap.get(heapId)
+            return when {
+                value.type in StringDatatypes ->
+                    RuntimeValue(value.type, str = value.str!!, heapId = heapId)
+                value.type in ArrayDatatypes ->
+                    if (value.type == DataType.ARRAY_F) {
+                        RuntimeValue(value.type, array = value.doubleArray!!.toList().toTypedArray(), heapId = heapId)
+                    } else {
+                        val array = value.array!!
+                        val resultArray = mutableListOf<Number>()
+                        for(elt in array.withIndex()){
+                            if(elt.value.integer!=null)
+                                resultArray.add(elt.value.integer!!)
+                            else {
+                                TODO("ADDRESSOF ${elt.value}")
+                            }
+                        }
+                        RuntimeValue(value.type, array = resultArray.toTypedArray(), heapId = heapId)
+                        //RuntimeValue(value.type, array = array.map { it.integer!! }.toTypedArray(), heapId = heapId)
+                    }
+                else -> throw IllegalArgumentException("weird value type on heap $value")
+            }
+        }
+
+    }
+
+    init {
+        when(type) {
+            DataType.UBYTE -> {
+                val inum = num!!.toInt()
+                if(inum !in 0 .. 255)
+                    throw IllegalArgumentException("invalid value for ubyte: $inum")
+                byteval = inum.toShort()
+                wordval = null
+                floatval = null
+                asBoolean = byteval != 0.toShort()
+            }
+            DataType.BYTE -> {
+                val inum = num!!.toInt()
+                if(inum !in -128 .. 127)
+                    throw IllegalArgumentException("invalid value for byte: $inum")
+                byteval = inum.toShort()
+                wordval = null
+                floatval = null
+                asBoolean = byteval != 0.toShort()
+            }
+            DataType.UWORD -> {
+                val inum = num!!.toInt()
+                if(inum !in 0 .. 65535)
+                    throw IllegalArgumentException("invalid value for uword: $inum")
+                wordval = inum
+                byteval = null
+                floatval = null
+                asBoolean = wordval != 0
+            }
+            DataType.WORD -> {
+                val inum = num!!.toInt()
+                if(inum !in -32768 .. 32767)
+                    throw IllegalArgumentException("invalid value for word: $inum")
+                wordval = inum
+                byteval = null
+                floatval = null
+                asBoolean = wordval != 0
+            }
+            DataType.FLOAT -> {
+                floatval = num!!.toDouble()
+                byteval = null
+                wordval = null
+                asBoolean = floatval != 0.0
+            }
+            else -> {
+                byteval = null
+                wordval = null
+                floatval = null
+                asBoolean = true
+            }
+        }
+    }
+
+    override fun toString(): String {
+        return when(type) {
+            DataType.UBYTE -> "ub:%02x".format(byteval)
+            DataType.BYTE -> {
+                if(byteval!!<0)
+                    "b:-%02x".format(abs(byteval.toInt()))
+                else
+                    "b:%02x".format(byteval)
+            }
+            DataType.UWORD -> "uw:%04x".format(wordval)
+            DataType.WORD -> {
+                if(wordval!!<0)
+                    "w:-%04x".format(abs(wordval))
+                else
+                    "w:%04x".format(wordval)
+            }
+            DataType.FLOAT -> "f:$floatval"
+            else -> "heap:$heapId"
+        }
+    }
+
+    fun numericValue(): Number {
+        return when(type) {
+            in ByteDatatypes -> byteval!!
+            in WordDatatypes -> wordval!!
+            DataType.FLOAT -> floatval!!
+            else -> throw ArithmeticException("invalid datatype for numeric value: $type")
+        }
+    }
+
+    fun integerValue(): Int {
+        return when(type) {
+            in ByteDatatypes -> byteval!!.toInt()
+            in WordDatatypes -> wordval!!
+            DataType.FLOAT -> throw ArithmeticException("float to integer loss of precision")
+            else -> throw ArithmeticException("invalid datatype for integer value: $type")
+        }
+    }
+
+    override fun hashCode(): Int {
+        val bh = byteval?.hashCode() ?: 0x10001234
+        val wh = wordval?.hashCode() ?: 0x01002345
+        val fh = floatval?.hashCode() ?: 0x00103456
+        return bh xor wh xor fh xor heapId.hashCode() xor type.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is RuntimeValue)
+            return false
+        if(type==other.type)
+            return if (type in IterableDatatypes) heapId==other.heapId else compareTo(other)==0
+        return compareTo(other)==0      // note: datatype doesn't matter
+    }
+
+    operator fun compareTo(other: RuntimeValue): Int {
+        return if (type in NumericDatatypes && other.type in NumericDatatypes)
+            numericValue().toDouble().compareTo(other.numericValue().toDouble())
+        else throw ArithmeticException("comparison can only be done between two numeric values")
+    }
+
+    private fun arithResult(leftDt: DataType, result: Number, rightDt: DataType, op: String): RuntimeValue {
+        if(leftDt!=rightDt)
+            throw ArithmeticException("left and right datatypes are not the same")
+        if(result.toDouble() < 0 ) {
+            return when(leftDt) {
+                DataType.UBYTE, DataType.UWORD -> {
+                    // storing a negative number in an unsigned one is done by storing the 2's complement instead
+                    val number = abs(result.toDouble().toInt())
+                    if(leftDt== DataType.UBYTE)
+                        RuntimeValue(DataType.UBYTE, (number xor 255) + 1)
+                    else
+                        RuntimeValue(DataType.UWORD, (number xor 65535) + 1)
+                }
+                DataType.BYTE -> {
+                    val v=result.toInt() and 255
+                    if(v<128)
+                        RuntimeValue(DataType.BYTE, v)
+                    else
+                        RuntimeValue(DataType.BYTE, v-256)
+                }
+                DataType.WORD -> {
+                    val v=result.toInt() and 65535
+                    if(v<32768)
+                        RuntimeValue(DataType.WORD, v)
+                    else
+                        RuntimeValue(DataType.WORD, v-65536)
+                }
+                DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+                else -> throw ArithmeticException("$op on non-numeric type")
+            }
+        }
+
+        return when(leftDt) {
+            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result.toInt() and 255)
+            DataType.BYTE -> {
+                val v = result.toInt() and 255
+                if(v<128)
+                    RuntimeValue(DataType.BYTE, v)
+                else
+                    RuntimeValue(DataType.BYTE, v-256)
+            }
+            DataType.UWORD -> RuntimeValue(DataType.UWORD, result.toInt() and 65535)
+            DataType.WORD -> {
+                val v = result.toInt() and 65535
+                if(v<32768)
+                    RuntimeValue(DataType.WORD, v)
+                else
+                    RuntimeValue(DataType.WORD, v-65536)
+            }
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+            else -> throw ArithmeticException("$op on non-numeric type")
+        }
+    }
+
+    fun add(other: RuntimeValue): RuntimeValue {
+        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+            throw ArithmeticException("floating point loss of precision on type $type")
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        val result = v1.toDouble() + v2.toDouble()
+        return arithResult(type, result, other.type, "add")
+    }
+
+    fun sub(other: RuntimeValue): RuntimeValue {
+        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+            throw ArithmeticException("floating point loss of precision on type $type")
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        val result = v1.toDouble() - v2.toDouble()
+        return arithResult(type, result, other.type, "sub")
+    }
+
+    fun mul(other: RuntimeValue): RuntimeValue {
+        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+            throw ArithmeticException("floating point loss of precision on type $type")
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        val result = v1.toDouble() * v2.toDouble()
+        return arithResult(type, result, other.type, "mul")
+    }
+
+    fun div(other: RuntimeValue): RuntimeValue {
+        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+            throw ArithmeticException("floating point loss of precision on type $type")
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        if(v2.toDouble()==0.0) {
+            when (type) {
+                DataType.UBYTE -> return RuntimeValue(DataType.UBYTE, 255)
+                DataType.BYTE -> return RuntimeValue(DataType.BYTE, 127)
+                DataType.UWORD -> return RuntimeValue(DataType.UWORD, 65535)
+                DataType.WORD -> return RuntimeValue(DataType.WORD, 32767)
+                else -> {}
+            }
+        }
+        val result = v1.toDouble() / v2.toDouble()
+        // NOTE: integer division returns integer result!
+        return when(type) {
+            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result)
+            DataType.BYTE -> RuntimeValue(DataType.BYTE, result)
+            DataType.UWORD -> RuntimeValue(DataType.UWORD, result)
+            DataType.WORD -> RuntimeValue(DataType.WORD, result)
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+            else -> throw ArithmeticException("div on non-numeric type")
+        }
+    }
+
+    fun remainder(other: RuntimeValue): RuntimeValue {
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        val result = v1.toDouble() % v2.toDouble()
+        return arithResult(type, result, other.type, "remainder")
+    }
+
+    fun pow(other: RuntimeValue): RuntimeValue {
+        val v1 = numericValue()
+        val v2 = other.numericValue()
+        val result = v1.toDouble().pow(v2.toDouble())
+        return arithResult(type, result, other.type,"pow")
+    }
+
+    fun shl(): RuntimeValue {
+        val v = integerValue()
+        return when (type) {
+            DataType.UBYTE -> RuntimeValue(type, (v shl 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (v shl 1) and 65535)
+            DataType.BYTE -> {
+                val value = v shl 1
+                if(value<128)
+                    RuntimeValue(type, value)
+                else
+                    RuntimeValue(type, value-256)
+            }
+            DataType.WORD -> {
+                val value = v shl 1
+                if(value<32768)
+                    RuntimeValue(type, value)
+                else
+                    RuntimeValue(type, value-65536)
+            }
+            else -> throw ArithmeticException("invalid type for shl: $type")
+        }
+    }
+
+    fun shr(): RuntimeValue {
+        val v = integerValue()
+        return when(type){
+            DataType.UBYTE -> RuntimeValue(type, v ushr 1)
+            DataType.BYTE -> RuntimeValue(type, v shr 1)
+            DataType.UWORD -> RuntimeValue(type, v ushr 1)
+            DataType.WORD -> RuntimeValue(type, v shr 1)
+            else -> throw ArithmeticException("invalid type for shr: $type")
+        }
+    }
+
+    fun rol(carry: Boolean): Pair<RuntimeValue, Boolean> {
+        // 9 or 17 bit rotate left (with carry))
+        return when(type) {
+            DataType.UBYTE, DataType.BYTE -> {
+                val v = byteval!!.toInt()
+                val newCarry = (v and 0x80) != 0
+                val newval = (v and 0x7f shl 1) or (if(carry) 1 else 0)
+                Pair(RuntimeValue(DataType.UBYTE, newval), newCarry)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                val v = wordval!!
+                val newCarry = (v and 0x8000) != 0
+                val newval = (v and 0x7fff shl 1) or (if(carry) 1 else 0)
+                Pair(RuntimeValue(DataType.UWORD, newval), newCarry)
+            }
+            else -> throw ArithmeticException("rol can only work on byte/word")
+        }
+    }
+
+    fun ror(carry: Boolean): Pair<RuntimeValue, Boolean> {
+        // 9 or 17 bit rotate right (with carry)
+        return when(type) {
+            DataType.UBYTE, DataType.BYTE -> {
+                val v = byteval!!.toInt()
+                val newCarry = v and 1 != 0
+                val newval = (v ushr 1) or (if(carry) 0x80 else 0)
+                Pair(RuntimeValue(DataType.UBYTE, newval), newCarry)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                val v = wordval!!
+                val newCarry = v and 1 != 0
+                val newval = (v ushr 1) or (if(carry) 0x8000 else 0)
+                Pair(RuntimeValue(DataType.UWORD, newval), newCarry)
+            }
+            else -> throw ArithmeticException("ror2 can only work on byte/word")
+        }
+    }
+
+    fun rol2(): RuntimeValue {
+        // 8 or 16 bit rotate left
+        return when(type) {
+            DataType.UBYTE, DataType.BYTE -> {
+                val v = byteval!!.toInt()
+                val carry = (v and 0x80) ushr 7
+                val newval = (v and 0x7f shl 1) or carry
+                RuntimeValue(DataType.UBYTE, newval)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                val v = wordval!!
+                val carry = (v and 0x8000) ushr 15
+                val newval = (v and 0x7fff shl 1) or carry
+                RuntimeValue(DataType.UWORD, newval)
+            }
+            else -> throw ArithmeticException("rol2 can only work on byte/word")
+        }
+    }
+
+    fun ror2(): RuntimeValue {
+        // 8 or 16 bit rotate right
+        return when(type) {
+            DataType.UBYTE, DataType.BYTE -> {
+                val v = byteval!!.toInt()
+                val carry = v and 1 shl 7
+                val newval = (v ushr 1) or carry
+                RuntimeValue(DataType.UBYTE, newval)
+            }
+            DataType.UWORD, DataType.WORD -> {
+                val v = wordval!!
+                val carry = v and 1 shl 15
+                val newval = (v ushr 1) or carry
+                RuntimeValue(DataType.UWORD, newval)
+            }
+            else -> throw ArithmeticException("ror2 can only work on byte/word")
+        }
+    }
+
+    fun neg(): RuntimeValue {
+        return when(type) {
+            DataType.BYTE -> RuntimeValue(DataType.BYTE, -(byteval!!))
+            DataType.WORD -> RuntimeValue(DataType.WORD, -(wordval!!))
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, -(floatval)!!)
+            else -> throw ArithmeticException("neg can only work on byte/word/float")
+        }
+    }
+
+    fun abs(): RuntimeValue {
+        return when(type) {
+            DataType.BYTE -> RuntimeValue(DataType.BYTE, abs(byteval!!.toInt()))
+            DataType.WORD -> RuntimeValue(DataType.WORD, abs(wordval!!))
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(floatval!!))
+            else -> throw ArithmeticException("abs can only work on byte/word/float")
+        }
+    }
+
+    fun bitand(other: RuntimeValue): RuntimeValue {
+        val v1 = integerValue()
+        val v2 = other.integerValue()
+        val result = v1 and v2
+        return RuntimeValue(type, result)
+    }
+
+    fun bitor(other: RuntimeValue): RuntimeValue {
+        val v1 = integerValue()
+        val v2 = other.integerValue()
+        val result = v1 or v2
+        return RuntimeValue(type, result)
+    }
+
+    fun bitxor(other: RuntimeValue): RuntimeValue {
+        val v1 = integerValue()
+        val v2 = other.integerValue()
+        val result = v1 xor v2
+        return RuntimeValue(type, result)
+    }
+
+    fun and(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean && other.asBoolean) 1 else 0)
+    fun or(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean || other.asBoolean) 1 else 0)
+    fun xor(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean xor other.asBoolean) 1 else 0)
+    fun not() = RuntimeValue(DataType.UBYTE, if (this.asBoolean) 0 else 1)
+
+    fun inv(): RuntimeValue {
+        return when(type) {
+            DataType.UBYTE -> RuntimeValue(type, byteval!!.toInt().inv() and 255)
+            DataType.UWORD -> RuntimeValue(type, wordval!!.inv() and 65535)
+            DataType.BYTE -> RuntimeValue(type, byteval!!.toInt().inv())
+            DataType.WORD -> RuntimeValue(type, wordval!!.inv())
+            else -> throw ArithmeticException("inv can only work on byte/word")
+        }
+    }
+
+    fun inc(): RuntimeValue {
+        return when(type) {
+            DataType.UBYTE -> RuntimeValue(type, (byteval!! + 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (wordval!! + 1) and 65535)
+            DataType.BYTE -> {
+                val newval = byteval!! + 1
+                if(newval == 128)
+                    RuntimeValue(type, -128)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.WORD -> {
+                val newval = wordval!! + 1
+                if(newval == 32768)
+                    RuntimeValue(type, -32768)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! + 1)
+            else -> throw ArithmeticException("inc can only work on numeric types")
+        }
+    }
+
+    fun dec(): RuntimeValue {
+        return when(type) {
+            DataType.UBYTE -> RuntimeValue(type, (byteval!! - 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (wordval!! - 1) and 65535)
+            DataType.BYTE -> {
+                val newval = byteval!! - 1
+                if(newval == -129)
+                    RuntimeValue(type, 127)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.WORD -> {
+                val newval = wordval!! - 1
+                if(newval == -32769)
+                    RuntimeValue(type, 32767)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! - 1)
+            else -> throw ArithmeticException("dec can only work on numeric types")
+        }
+    }
+
+    fun msb(): RuntimeValue {
+        return when(type) {
+            in ByteDatatypes -> RuntimeValue(DataType.UBYTE, 0)
+            in WordDatatypes -> RuntimeValue(DataType.UBYTE, wordval!! ushr 8 and 255)
+            else -> throw ArithmeticException("msb can only work on (u)byte/(u)word")
+        }
+    }
+
+    fun cast(targetType: DataType): RuntimeValue {
+        return when (type) {
+            DataType.UBYTE -> {
+                when (targetType) {
+                    DataType.UBYTE -> this
+                    DataType.BYTE -> {
+                        val nval=byteval!!.toInt()
+                        if(nval<128)
+                            RuntimeValue(DataType.BYTE, nval)
+                        else
+                            RuntimeValue(DataType.BYTE, nval-256)
+                    }
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, numericValue())
+                    DataType.WORD -> {
+                        val nval = numericValue().toInt()
+                        if(nval<32768)
+                            RuntimeValue(DataType.WORD, nval)
+                        else
+                            RuntimeValue(DataType.WORD, nval-65536)
+                    }
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+                }
+            }
+            DataType.BYTE -> {
+                when (targetType) {
+                    DataType.BYTE -> this
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue() and 65535)
+                    DataType.WORD -> RuntimeValue(DataType.WORD, integerValue())
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+                }
+            }
+            DataType.UWORD -> {
+                when (targetType) {
+                    DataType.BYTE -> {
+                        val v=integerValue()
+                        if(v<128)
+                            RuntimeValue(DataType.BYTE, v)
+                        else
+                            RuntimeValue(DataType.BYTE, v-256)
+                    }
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
+                    DataType.UWORD -> this
+                    DataType.WORD -> {
+                        val v=integerValue()
+                        if(v<32768)
+                            RuntimeValue(DataType.WORD, v)
+                        else
+                            RuntimeValue(DataType.WORD, v-65536)
+                    }
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+                }
+            }
+            DataType.WORD -> {
+                when (targetType) {
+                    DataType.BYTE -> {
+                        val v = integerValue() and 255
+                        if(v<128)
+                            RuntimeValue(DataType.BYTE, v)
+                        else
+                            RuntimeValue(DataType.BYTE, v-256)
+                    }
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 65535)
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue())
+                    DataType.WORD -> this
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+                }
+            }
+            DataType.FLOAT -> {
+                when (targetType) {
+                    DataType.BYTE -> {
+                        val integer=numericValue().toInt()
+                        if(integer in -128..127)
+                            RuntimeValue(DataType.BYTE, integer)
+                        else
+                            throw ArithmeticException("overflow when casting float to byte: $this")
+                    }
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, numericValue().toInt())
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, numericValue().toInt())
+                    DataType.WORD -> {
+                        val integer=numericValue().toInt()
+                        if(integer in -32768..32767)
+                            RuntimeValue(DataType.WORD, integer)
+                        else
+                            throw ArithmeticException("overflow when casting float to word: $this")
+                    }
+                    DataType.FLOAT -> this
+                    else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+                }
+            }
+            else -> throw ArithmeticException("invalid type cast from $type to $targetType")
+        }
+    }
+
+    open fun iterator(): Iterator<Number> {
+        return when (type) {
+            in StringDatatypes -> {
+                Petscii.encodePetscii(str!!, true).iterator()
+            }
+            in ArrayDatatypes -> {
+                array!!.iterator()
+            }
+            else -> throw IllegalArgumentException("cannot iterate over $this")
+        }
+    }
+}
+
+
+class RuntimeValueRange(type: DataType, val range: IntProgression): RuntimeValue(type, array=range.toList().toTypedArray()) {
+    override fun iterator(): Iterator<Number> {
+        return range.iterator()
+    }
+}

compiler/src/prog8/vm/astvm/AstVm.kt

@@ -0,0 +1,961 @@
+package prog8.vm.astvm
+
+import prog8.ast.INameScope
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.Expression
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.statements.*
+import prog8.compiler.IntegerOrAddressOf
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.Petscii
+import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueRange
+import java.awt.EventQueue
+import java.io.CharConversionException
+import java.util.*
+import kotlin.NoSuchElementException
+import kotlin.concurrent.fixedRateTimer
+import kotlin.math.*
+import kotlin.random.Random
+
+
+class VmExecutionException(msg: String?) : Exception(msg)
+
+class VmTerminationException(msg: String?) : Exception(msg)
+
+class VmBreakpointException : Exception("breakpoint")
+
+
+class StatusFlags {
+    var carry: Boolean = false
+    var zero: Boolean = true
+    var negative: Boolean = false
+    var irqd: Boolean = false
+
+    private fun setFlags(value: NumericLiteralValue?) {
+        if (value != null) {
+            when (value.type) {
+                DataType.UBYTE -> {
+                    val v = value.number.toInt()
+                    negative = v > 127
+                    zero = v == 0
+                }
+                DataType.BYTE -> {
+                    val v = value.number.toInt()
+                    negative = v < 0
+                    zero = v == 0
+                }
+                DataType.UWORD -> {
+                    val v = value.number.toInt()
+                    negative = v > 32767
+                    zero = v == 0
+                }
+                DataType.WORD -> {
+                    val v = value.number.toInt()
+                    negative = v < 0
+                    zero = v == 0
+                }
+                DataType.FLOAT -> {
+                    val flt = value.number.toDouble()
+                    negative = flt < 0.0
+                    zero = flt == 0.0
+                }
+                else -> {
+                    // no flags for non-numeric type
+                }
+            }
+        }
+    }
+}
+
+
+class RuntimeVariables {
+    fun define(scope: INameScope, name: String, initialValue: RuntimeValue) {
+        val where = vars.getValue(scope)
+        where[name] = initialValue
+        vars[scope] = where
+    }
+
+    fun defineMemory(scope: INameScope, name: String, address: Int) {
+        val where = memvars.getValue(scope)
+        where[name] = address
+        memvars[scope] = where
+    }
+
+    fun set(scope: INameScope, name: String, value: RuntimeValue) {
+        val where = vars.getValue(scope)
+        val existing = where[name]
+        if(existing==null) {
+            if(memvars.getValue(scope)[name]!=null)
+                throw NoSuchElementException("this is a memory mapped var, not a normal var: ${scope.name}.$name")
+            throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
+        }
+        if(existing.type!=value.type)
+            throw VmExecutionException("new value is of different datatype ${value.type} expected ${existing.type} for $name")
+        where[name] = value
+        vars[scope] = where
+    }
+
+    fun get(scope: INameScope, name: String): RuntimeValue {
+        val where = vars.getValue(scope)
+        return where[name] ?: throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
+    }
+
+    fun getMemoryAddress(scope: INameScope, name: String): Int {
+        val where = memvars.getValue(scope)
+        return where[name] ?: throw NoSuchElementException("no such runtime memory-variable: ${scope.name}.$name")
+    }
+
+    fun swap(a1: VarDecl, a2: VarDecl) = swap(a1.definingScope(), a1.name, a2.definingScope(), a2.name)
+
+    fun swap(scope1: INameScope, name1: String, scope2: INameScope, name2: String) {
+        val v1 = get(scope1, name1)
+        val v2 = get(scope2, name2)
+        set(scope1, name1, v2)
+        set(scope2, name2, v1)
+    }
+
+    private val vars = mutableMapOf<INameScope, MutableMap<String, RuntimeValue>>().withDefault { mutableMapOf() }
+    private val memvars = mutableMapOf<INameScope, MutableMap<String, Int>>().withDefault { mutableMapOf() }
+}
+
+
+class AstVm(val program: Program) {
+
+    val mem = Memory(::memread, ::memwrite)
+    val statusflags = StatusFlags()
+
+    private var dialog = ScreenDialog("AstVM")
+    var instructionCounter = 0
+    val bootTime = System.currentTimeMillis()
+    var rtcOffset = bootTime
+
+    private val rnd = Random(0)
+    private val statusFlagsSave = Stack<StatusFlags>()
+    private val registerXsave = Stack<RuntimeValue>()
+    private val registerYsave = Stack<RuntimeValue>()
+    private val registerAsave = Stack<RuntimeValue>()
+
+
+    init {
+        // observe the jiffyclock and screen matrix
+        mem.observe(0xa0, 0xa1, 0xa2)
+        for(i in 1024..2023)
+            mem.observe(i)
+
+        dialog.requestFocusInWindow()
+
+        EventQueue.invokeLater {
+            dialog.pack()
+            dialog.isVisible = true
+            dialog.start()
+        }
+
+        fixedRateTimer("60hz-irq", true, period=1000/60) {
+            irq(this.scheduledExecutionTime())
+        }
+    }
+
+    fun memread(address: Int, value: Short): Short {
+        // println("MEM READ  $address  -> $value")
+        return value
+    }
+
+    fun memwrite(address: Int, value: Short): Short {
+        if(address==0xa0 || address==0xa1 || address==0xa2) {
+            // a write to the jiffy clock, update the clock offset for the irq
+            val time_hi = if(address==0xa0) value else mem.getUByte_DMA(0xa0)
+            val time_mid = if(address==0xa1) value else mem.getUByte_DMA(0xa1)
+            val time_lo = if(address==0xa2) value else mem.getUByte_DMA(0xa2)
+            val jiffies = (time_hi.toInt() shl 16) + (time_mid.toInt() shl 8) + time_lo
+            rtcOffset = bootTime - (jiffies*1000/60)
+        }
+        if(address in 1024..2023) {
+            // write to the screen matrix
+            val scraddr = address-1024
+            dialog.canvas.setChar(scraddr % 40, scraddr / 40, value, 1)
+        }
+        return value
+    }
+
+    fun run() {
+        try {
+            val init = VariablesCreator(runtimeVariables, program.heap)
+            init.visit(program)
+
+            // initialize all global variables
+            for (m in program.modules) {
+                for (b in m.statements.filterIsInstance<Block>()) {
+                    for (s in b.statements.filterIsInstance<Subroutine>()) {
+                        if (s.name == initvarsSubName) {
+                            try {
+                                executeSubroutine(s, emptyList(), null)
+                            } catch (x: LoopControlReturn) {
+                                // regular return
+                            }
+                        }
+                    }
+                }
+            }
+
+            var entrypoint: Subroutine? = program.entrypoint() ?: throw VmTerminationException("no valid entrypoint found")
+            var startlabel: Label? = null
+
+            while(entrypoint!=null) {
+                try {
+                    executeSubroutine(entrypoint, emptyList(), startlabel)
+                    entrypoint = null
+                } catch (rx: LoopControlReturn) {
+                    // regular return
+                } catch (jx: LoopControlJump) {
+                    if (jx.address != null)
+                        throw VmTerminationException("doesn't support jumping to machine address ${jx.address}")
+                    when {
+                        jx.generatedLabel != null -> {
+                            val label = entrypoint.getLabelOrVariable(jx.generatedLabel) as Label
+                            TODO("generatedlabel $label")
+                        }
+                        jx.identifier != null -> {
+                            when (val jumptarget = entrypoint.lookup(jx.identifier.nameInSource, jx.identifier.parent)) {
+                                is Label -> {
+                                    startlabel = jumptarget
+                                    entrypoint = jumptarget.definingSubroutine()
+                                }
+                                is Subroutine -> entrypoint = jumptarget
+                                else -> throw VmTerminationException("weird jump target $jumptarget")
+                            }
+                        }
+                        else -> throw VmTerminationException("unspecified jump target")
+                    }
+                }
+            }
+            dialog.canvas.printText("\n<program ended>", true)
+            println("PROGRAM EXITED!")
+            dialog.title = "PROGRAM EXITED"
+        } catch (tx: VmTerminationException) {
+            println("Execution halted: ${tx.message}")
+        } catch (xx: VmExecutionException) {
+            println("Execution error: ${xx.message}")
+            throw xx
+        }
+    }
+
+    private fun irq(timeStamp: Long) {
+        // 60hz IRQ handling
+        if(statusflags.irqd)
+            return      // interrupt is disabled
+
+        var jiffies = (timeStamp-rtcOffset)*60/1000
+        if(jiffies>24*3600*60-1) {
+            jiffies = 0
+            rtcOffset = timeStamp
+        }
+        // update the C-64 60hz jiffy clock in the ZP addresses:
+        mem.setUByte_DMA(0x00a0, (jiffies ushr 16).toShort())
+        mem.setUByte_DMA(0x00a1, (jiffies ushr 8 and 255).toShort())
+        mem.setUByte_DMA(0x00a2, (jiffies and 255).toShort())
+    }
+
+    private val runtimeVariables = RuntimeVariables()
+    private val evalCtx = EvalContext(program, mem, statusflags, runtimeVariables, ::performBuiltinFunction, ::executeSubroutine)
+
+    class LoopControlBreak : Exception()
+    class LoopControlContinue : Exception()
+    class LoopControlReturn(val returnvalue: RuntimeValue?) : Exception()
+    class LoopControlJump(val identifier: IdentifierReference?, val address: Int?, val generatedLabel: String?) : Exception()
+
+
+    internal fun executeSubroutine(sub: Subroutine, arguments: List<RuntimeValue>, startAtLabel: Label?=null): RuntimeValue? {
+        if(sub.isAsmSubroutine) {
+            return performSyscall(sub, arguments)
+        }
+
+        if (sub.statements.isEmpty())
+            throw VmTerminationException("scope contains no statements: $sub")
+        if (arguments.size != sub.parameters.size)
+            throw VmTerminationException("number of args doesn't match number of required parameters")
+
+        for (arg in sub.parameters.zip(arguments)) {
+            val idref = IdentifierReference(listOf(arg.first.name), sub.position)
+            performAssignment(AssignTarget(null, idref, null, null, idref.position),
+                    arg.second, sub.statements.first(), evalCtx)
+        }
+
+        val statements = sub.statements.iterator()
+        if(startAtLabel!=null) {
+            do {
+                val stmt = statements.next()
+            } while(stmt!==startAtLabel)
+        }
+
+        try {
+            while(statements.hasNext()) {
+                val s = statements.next()
+                try {
+                    executeStatement(sub, s)
+                }
+                catch (b: VmBreakpointException) {
+                    print("BREAKPOINT HIT at ${s.position} - Press enter to continue:")
+                    readLine()
+                }
+            }
+        } catch (r: LoopControlReturn) {
+            return r.returnvalue
+        }
+        throw VmTerminationException("instruction pointer overflow, is a return missing? $sub")
+    }
+
+    internal fun executeAnonymousScope(scope: INameScope) {
+        for (s in scope.statements) {
+            executeStatement(scope, s)
+        }
+    }
+
+
+    private fun executeStatement(sub: INameScope, stmt: Statement) {
+        instructionCounter++
+        if (instructionCounter % 200 == 0)
+            Thread.sleep(1)
+        when (stmt) {
+            is NopStatement, is Label, is Subroutine -> {
+                // do nothing, skip this instruction
+            }
+            is Directive -> {
+                if (stmt.directive == "%breakpoint")
+                    throw VmBreakpointException()
+                else if (stmt.directive == "%asm")
+                    throw VmExecutionException("can't execute assembly code")
+            }
+            is VarDecl -> {
+                // should have been defined already when the program started
+            }
+            is FunctionCallStatement -> {
+                val target = stmt.target.targetStatement(program.namespace)
+                when (target) {
+                    is Subroutine -> {
+                        val args = evaluate(stmt.arglist)
+                        if (target.isAsmSubroutine) {
+                            performSyscall(target, args)
+                        } else {
+                            executeSubroutine(target, args, null)
+                            // any return value(s) are discarded
+                        }
+                    }
+                    is BuiltinFunctionStatementPlaceholder -> {
+                        if(target.name=="swap") {
+                            // swap cannot be implemented as a function, so inline it here
+                            executeSwap(stmt)
+                        } else {
+                            val args = evaluate(stmt.arglist)
+                            performBuiltinFunction(target.name, args, statusflags)
+                        }
+                    }
+                    else -> {
+                        TODO("weird call $target")
+                    }
+                }
+            }
+            is Return -> {
+                val value =
+                        if(stmt.value==null)
+                            null
+                        else
+                            evaluate(stmt.value!!, evalCtx)
+                throw LoopControlReturn(value)
+            }
+            is Continue -> throw LoopControlContinue()
+            is Break -> throw LoopControlBreak()
+            is Assignment -> {
+                if (stmt.aug_op != null)
+                    throw VmExecutionException("augmented assignment should have been converted into regular one $stmt")
+                val value = evaluate(stmt.value, evalCtx)
+                performAssignment(stmt.target, value, stmt, evalCtx)
+            }
+            is PostIncrDecr -> {
+                when {
+                    stmt.target.identifier != null -> {
+                        val ident = stmt.definingScope().lookup(stmt.target.identifier!!.nameInSource, stmt) as VarDecl
+                        val identScope = ident.definingScope()
+                        when(ident.type){
+                            VarDeclType.VAR -> {
+                                var value = runtimeVariables.get(identScope, ident.name)
+                                value = when {
+                                    stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
+                                    stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                                    else -> throw VmExecutionException("strange postincdec operator $stmt")
+                                }
+                                runtimeVariables.set(identScope, ident.name, value)
+                            }
+                            VarDeclType.MEMORY -> {
+                                val addr=ident.value!!.constValue(program)!!.number.toInt()
+                                val newval = when {
+                                    stmt.operator == "++" -> mem.getUByte(addr)+1 and 255
+                                    stmt.operator == "--" -> mem.getUByte(addr)-1 and 255
+                                    else -> throw VmExecutionException("strange postincdec operator $stmt")
+                                }
+                                mem.setUByte(addr,newval.toShort())
+                            }
+                            VarDeclType.CONST -> throw VmExecutionException("can't be const")
+                        }
+                    }
+                    stmt.target.memoryAddress != null -> {
+                        val addr = evaluate(stmt.target.memoryAddress!!.addressExpression, evalCtx).integerValue()
+                        val newval = when {
+                            stmt.operator == "++" -> mem.getUByte(addr)+1 and 255
+                            stmt.operator == "--" -> mem.getUByte(addr)-1 and 255
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        mem.setUByte(addr,newval.toShort())
+                    }
+                    stmt.target.arrayindexed != null -> {
+                        val arrayvar = stmt.target.arrayindexed!!.identifier.targetVarDecl(program.namespace)!!
+                        val arrayvalue = runtimeVariables.get(arrayvar.definingScope(), arrayvar.name)
+                        val elementType = stmt.target.arrayindexed!!.inferType(program)!!
+                        val index = evaluate(stmt.target.arrayindexed!!.arrayspec.index, evalCtx).integerValue()
+                        var value = RuntimeValue(elementType, arrayvalue.array!![index].toInt())
+                        value = when {
+                            stmt.operator == "++" -> value.inc()
+                            stmt.operator == "--" -> value.dec()
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        arrayvalue.array[index] = value.numericValue()
+                    }
+                    stmt.target.register != null -> {
+                        var value = runtimeVariables.get(program.namespace, stmt.target.register!!.name)
+                        value = when {
+                            stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
+                            stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        runtimeVariables.set(program.namespace, stmt.target.register!!.name, value)
+                    }
+                    else -> throw VmExecutionException("empty postincrdecr? $stmt")
+                }
+            }
+            is Jump -> throw LoopControlJump(stmt.identifier, stmt.address, stmt.generatedLabel)
+            is InlineAssembly -> {
+                if (sub is Subroutine) {
+                    val args = sub.parameters.map { runtimeVariables.get(sub, it.name) }
+                    performSyscall(sub, args)
+                    throw LoopControlReturn(null)
+                }
+                throw VmExecutionException("can't execute inline assembly in $sub")
+            }
+            is AnonymousScope -> executeAnonymousScope(stmt)
+            is IfStatement -> {
+                val condition = evaluate(stmt.condition, evalCtx)
+                if (condition.asBoolean)
+                    executeAnonymousScope(stmt.truepart)
+                else
+                    executeAnonymousScope(stmt.elsepart)
+            }
+            is BranchStatement -> {
+                when(stmt.condition) {
+                    BranchCondition.CS -> if(statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.CC -> if(!statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.EQ, BranchCondition.Z -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.NE, BranchCondition.NZ -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.MI, BranchCondition.NEG -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.PL, BranchCondition.POS -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.VS, BranchCondition.VC -> TODO("overflow status")
+                }
+            }
+            is ForLoop -> {
+                val iterable = evaluate(stmt.iterable, evalCtx)
+                if (iterable.type !in IterableDatatypes && iterable !is RuntimeValueRange)
+                    throw VmExecutionException("can only iterate over an iterable value:  $stmt")
+                val loopvarDt: DataType
+                val loopvar: IdentifierReference
+                if (stmt.loopRegister != null) {
+                    loopvarDt = DataType.UBYTE
+                    loopvar = IdentifierReference(listOf(stmt.loopRegister.name), stmt.position)
+                } else {
+                    loopvarDt = stmt.loopVar!!.inferType(program)!!
+                    loopvar = stmt.loopVar!!
+                }
+                val iterator = iterable.iterator()
+                for (loopvalue in iterator) {
+                    try {
+                        oneForCycle(stmt, loopvarDt, loopvalue, loopvar)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                }
+            }
+            is WhileLoop -> {
+                var condition = evaluate(stmt.condition, evalCtx)
+                while (condition.asBoolean) {
+                    try {
+                        executeAnonymousScope(stmt.body)
+                        condition = evaluate(stmt.condition, evalCtx)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                }
+            }
+            is RepeatLoop -> {
+                do {
+                    val condition = evaluate(stmt.untilCondition, evalCtx)
+                    try {
+                        executeAnonymousScope(stmt.body)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                } while (!condition.asBoolean)
+            }
+            is WhenStatement -> {
+                val condition=evaluate(stmt.condition, evalCtx)
+                for(choice in stmt.choices) {
+                    if(choice.values==null) {
+                        // the 'else' choice
+                        executeAnonymousScope(choice.statements)
+                        break
+                    } else {
+                        val value = choice.values!!.single().constValue(evalCtx.program) ?: throw VmExecutionException("can only use const values in when choices ${choice.position}")
+                        val rtval = RuntimeValue.fromLv(value)
+                        if(condition==rtval) {
+                            executeAnonymousScope(choice.statements)
+                            break
+                        }
+                    }
+                }
+            }
+            else -> {
+                TODO("implement $stmt")
+            }
+        }
+    }
+
+    private fun executeSwap(swap: FunctionCallStatement) {
+        val v1 = swap.arglist[0]
+        val v2 = swap.arglist[1]
+        val value1 = evaluate(v1, evalCtx)
+        val value2 = evaluate(v2, evalCtx)
+        val target1 = AssignTarget.fromExpr(v1)
+        val target2 = AssignTarget.fromExpr(v2)
+        performAssignment(target1, value2, swap, evalCtx)
+        performAssignment(target2, value1, swap, evalCtx)
+    }
+
+    fun performAssignment(target: AssignTarget, value: RuntimeValue, contextStmt: Statement, evalCtx: EvalContext) {
+        val targetIdent = target.identifier
+        val targetArrayIndexed = target.arrayindexed
+        when {
+            targetIdent != null -> {
+                val decl = contextStmt.definingScope().lookup(targetIdent.nameInSource, contextStmt) as? VarDecl
+                        ?: throw VmExecutionException("can't find assignment target $targetIdent")
+                if (decl.type == VarDeclType.MEMORY) {
+                    val address = runtimeVariables.getMemoryAddress(decl.definingScope(), decl.name)
+                    when (decl.datatype) {
+                        DataType.UBYTE -> mem.setUByte(address, value.byteval!!)
+                        DataType.BYTE -> mem.setSByte(address, value.byteval!!)
+                        DataType.UWORD -> mem.setUWord(address, value.wordval!!)
+                        DataType.WORD -> mem.setSWord(address, value.wordval!!)
+                        DataType.FLOAT -> mem.setFloat(address, value.floatval!!)
+                        DataType.STR -> mem.setString(address, value.str!!)
+                        DataType.STR_S -> mem.setScreencodeString(address, value.str!!)
+                        else -> throw VmExecutionException("weird memaddress type $decl")
+                    }
+                } else
+                    runtimeVariables.set(decl.definingScope(), decl.name, value)
+            }
+            target.memoryAddress != null -> {
+                val address = evaluate(target.memoryAddress.addressExpression, evalCtx).wordval!!
+                evalCtx.mem.setUByte(address, value.byteval!!)
+            }
+            targetArrayIndexed != null -> {
+                val vardecl = targetArrayIndexed.identifier.targetVarDecl(program.namespace)!!
+                if(vardecl.type==VarDeclType.VAR) {
+                    val array = evaluate(targetArrayIndexed.identifier, evalCtx)
+                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx)
+                    when (array.type) {
+                        DataType.ARRAY_UB -> {
+                            if (value.type != DataType.UBYTE)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_B -> {
+                            if (value.type != DataType.BYTE)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_UW -> {
+                            if (value.type != DataType.UWORD)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_W -> {
+                            if (value.type != DataType.WORD)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_F -> {
+                            if (value.type != DataType.FLOAT)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.STR, DataType.STR_S -> {
+                            if (value.type !in ByteDatatypes)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        else -> throw VmExecutionException("strange array type ${array.type}")
+                    }
+                    if (array.type in ArrayDatatypes)
+                        array.array!![index.integerValue()] = value.numericValue()
+                    else if (array.type in StringDatatypes) {
+                        val indexInt = index.integerValue()
+                        val newchr = Petscii.decodePetscii(listOf(value.numericValue().toShort()), true)
+                        val newstr = array.str!!.replaceRange(indexInt, indexInt + 1, newchr)
+                        val ident = contextStmt.definingScope().lookup(targetArrayIndexed.identifier.nameInSource, contextStmt) as? VarDecl
+                                ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
+                        val identScope = ident.definingScope()
+                        program.heap.update(array.heapId!!, newstr)
+                        runtimeVariables.set(identScope, ident.name, RuntimeValue(array.type, str = newstr, heapId = array.heapId))
+                    }
+                }
+                else {
+                    val address = (vardecl.value as NumericLiteralValue).number.toInt()
+                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx).integerValue()
+                    val elementType = targetArrayIndexed.inferType(program)!!
+                    when(elementType) {
+                        DataType.UBYTE -> mem.setUByte(address+index, value.byteval!!)
+                        DataType.BYTE -> mem.setSByte(address+index, value.byteval!!)
+                        DataType.UWORD -> mem.setUWord(address+index*2, value.wordval!!)
+                        DataType.WORD -> mem.setSWord(address+index*2, value.wordval!!)
+                        DataType.FLOAT -> mem.setFloat(address+index* MachineDefinition.Mflpt5.MemorySize, value.floatval!!)
+                        else -> throw VmExecutionException("strange array elt type $elementType")
+                    }
+                }
+            }
+            target.register != null -> {
+                runtimeVariables.set(program.namespace, target.register.name, value)
+            }
+            else -> TODO("assign $target")
+        }
+    }
+
+    private fun oneForCycle(stmt: ForLoop, loopvarDt: DataType, loopValue: Number, loopVar: IdentifierReference) {
+        // assign the new loop value to the loopvar, and run the code
+        performAssignment(AssignTarget(null, loopVar, null, null, loopVar.position),
+                RuntimeValue(loopvarDt, loopValue), stmt.body.statements.first(), evalCtx)
+        executeAnonymousScope(stmt.body)
+    }
+
+    private fun evaluate(args: List<Expression>) = args.map { evaluate(it, evalCtx) }
+
+    private fun performSyscall(sub: Subroutine, args: List<RuntimeValue>): RuntimeValue? {
+        var result: RuntimeValue? = null
+        when (sub.scopedname) {
+            "c64scr.print" -> {
+                // if the argument is an UWORD, consider it to be the "address" of the string (=heapId)
+                if (args[0].wordval != null) {
+                    val str = program.heap.get(args[0].wordval!!).str!!
+                    dialog.canvas.printText(str, true)
+                } else
+                    dialog.canvas.printText(args[0].str!!, true)
+            }
+            "c64scr.print_ub" -> {
+                dialog.canvas.printText(args[0].byteval!!.toString(), true)
+            }
+            "c64scr.print_ub0" -> {
+                dialog.canvas.printText("%03d".format(args[0].byteval!!), true)
+            }
+            "c64scr.print_b" -> {
+                dialog.canvas.printText(args[0].byteval!!.toString(), true)
+            }
+            "c64scr.print_uw" -> {
+                dialog.canvas.printText(args[0].wordval!!.toString(), true)
+            }
+            "c64scr.print_uw0" -> {
+                dialog.canvas.printText("%05d".format(args[0].wordval!!), true)
+            }
+            "c64scr.print_w" -> {
+                dialog.canvas.printText(args[0].wordval!!.toString(), true)
+            }
+            "c64scr.print_ubhex" -> {
+                val number = args[0].byteval!!
+                val prefix = if (args[1].asBoolean) "$" else ""
+                dialog.canvas.printText("$prefix${number.toString(16).padStart(2, '0')}", true)
+            }
+            "c64scr.print_uwhex" -> {
+                val number = args[0].wordval!!
+                val prefix = if (args[1].asBoolean) "$" else ""
+                dialog.canvas.printText("$prefix${number.toString(16).padStart(4, '0')}", true)
+            }
+            "c64scr.print_uwbin" -> {
+                val number = args[0].wordval!!
+                val prefix = if (args[1].asBoolean) "%" else ""
+                dialog.canvas.printText("$prefix${number.toString(2).padStart(16, '0')}", true)
+            }
+            "c64scr.print_ubbin" -> {
+                val number = args[0].byteval!!
+                val prefix = if (args[1].asBoolean) "%" else ""
+                dialog.canvas.printText("$prefix${number.toString(2).padStart(8, '0')}", true)
+            }
+            "c64scr.clear_screenchars" -> {
+                dialog.canvas.clearScreen(6)
+            }
+            "c64scr.clear_screen" -> {
+                dialog.canvas.clearScreen(args[0].integerValue().toShort())
+            }
+            "c64scr.setcc" -> {
+                dialog.canvas.setChar(args[0].integerValue(), args[1].integerValue(), args[2].integerValue().toShort(), args[3].integerValue().toShort())
+            }
+            "c64scr.plot" -> {
+                dialog.canvas.setCursorPos(args[0].integerValue(), args[1].integerValue())
+            }
+            "c64scr.input_chars" -> {
+                val input=mutableListOf<Char>()
+                for(i in 0 until 80) {
+                    while(dialog.keyboardBuffer.isEmpty()) {
+                        Thread.sleep(10)
+                    }
+                    val char=dialog.keyboardBuffer.pop()
+                    if(char=='\n')
+                        break
+                    else {
+                        input.add(char)
+                        val printChar = try {
+                            Petscii.encodePetscii("" + char, true).first()
+                        } catch (cv: CharConversionException) {
+                            0x3f.toShort()
+                        }
+                        dialog.canvas.printPetscii(printChar)
+                    }
+                }
+                val inputStr = input.joinToString("")
+                val heapId = args[0].wordval!!
+                val origStr = program.heap.get(heapId).str!!
+                val paddedStr=inputStr.padEnd(origStr.length+1, '\u0000').substring(0, origStr.length)
+                program.heap.update(heapId, paddedStr)
+                result = RuntimeValue(DataType.UBYTE, paddedStr.indexOf('\u0000'))
+            }
+            "c64flt.print_f" -> {
+                dialog.canvas.printText(args[0].floatval.toString(), false)
+            }
+            "c64.CHROUT" -> {
+                dialog.canvas.printPetscii(args[0].byteval!!)
+            }
+            "c64.CLEARSCR" -> {
+                dialog.canvas.clearScreen(6)
+            }
+            "c64.CHRIN" -> {
+                while(dialog.keyboardBuffer.isEmpty()) {
+                    Thread.sleep(10)
+                }
+                val char=dialog.keyboardBuffer.pop()
+                result = RuntimeValue(DataType.UBYTE, char.toShort())
+            }
+            "c64utils.str2uword" -> {
+                val heapId = args[0].wordval!!
+                val argString = program.heap.get(heapId).str!!
+                val numericpart = argString.takeWhile { it.isDigit() }
+                result = RuntimeValue(DataType.UWORD, numericpart.toInt() and 65535)
+            }
+            else -> TODO("syscall  ${sub.scopedname} $sub")
+        }
+
+        return result
+    }
+
+    private fun performBuiltinFunction(name: String, args: List<RuntimeValue>, statusflags: StatusFlags): RuntimeValue? {
+        return when (name) {
+            "rnd" -> RuntimeValue(DataType.UBYTE, rnd.nextInt() and 255)
+            "rndw" -> RuntimeValue(DataType.UWORD, rnd.nextInt() and 65535)
+            "rndf" -> RuntimeValue(DataType.FLOAT, rnd.nextDouble())
+            "lsb" -> RuntimeValue(DataType.UBYTE, args[0].integerValue() and 255)
+            "msb" -> RuntimeValue(DataType.UBYTE, (args[0].integerValue() ushr 8) and 255)
+            "sin" -> RuntimeValue(DataType.FLOAT, sin(args[0].numericValue().toDouble()))
+            "sin8" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (127.0 * sin(rad)).toShort())
+            }
+            "sin8u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort())
+            }
+            "sin16" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (32767.0 * sin(rad)).toShort())
+            }
+            "sin16u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * sin(rad)).toShort())
+            }
+            "cos" -> RuntimeValue(DataType.FLOAT, cos(args[0].numericValue().toDouble()))
+            "cos8" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (127.0 * cos(rad)).toShort())
+            }
+            "cos8u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort())
+            }
+            "cos16" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (32767.0 * cos(rad)).toShort())
+            }
+            "cos16u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * cos(rad)).toShort())
+            }
+            "tan" -> RuntimeValue(DataType.FLOAT, tan(args[0].numericValue().toDouble()))
+            "atan" -> RuntimeValue(DataType.FLOAT, atan(args[0].numericValue().toDouble()))
+            "ln" -> RuntimeValue(DataType.FLOAT, ln(args[0].numericValue().toDouble()))
+            "log2" -> RuntimeValue(DataType.FLOAT, log2(args[0].numericValue().toDouble()))
+            "sqrt" -> RuntimeValue(DataType.FLOAT, sqrt(args[0].numericValue().toDouble()))
+            "sqrt16" -> RuntimeValue(DataType.UBYTE, sqrt(args[0].wordval!!.toDouble()).toInt())
+            "rad" -> RuntimeValue(DataType.FLOAT, Math.toRadians(args[0].numericValue().toDouble()))
+            "deg" -> RuntimeValue(DataType.FLOAT, Math.toDegrees(args[0].numericValue().toDouble()))
+            "round" -> RuntimeValue(DataType.FLOAT, round(args[0].numericValue().toDouble()))
+            "floor" -> RuntimeValue(DataType.FLOAT, floor(args[0].numericValue().toDouble()))
+            "ceil" -> RuntimeValue(DataType.FLOAT, ceil(args[0].numericValue().toDouble()))
+            "rol" -> {
+                val (result, newCarry) = args[0].rol(statusflags.carry)
+                statusflags.carry = newCarry
+                return result
+            }
+            "rol2" -> args[0].rol2()
+            "ror" -> {
+                val (result, newCarry) = args[0].ror(statusflags.carry)
+                statusflags.carry = newCarry
+                return result
+            }
+            "ror2" -> args[0].ror2()
+            "lsl" -> args[0].shl()
+            "lsr" -> args[0].shr()
+            "abs" -> {
+                when (args[0].type) {
+                    DataType.UBYTE -> args[0]
+                    DataType.BYTE -> RuntimeValue(DataType.UBYTE, abs(args[0].numericValue().toDouble()))
+                    DataType.UWORD -> args[0]
+                    DataType.WORD -> RuntimeValue(DataType.UWORD, abs(args[0].numericValue().toDouble()))
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(args[0].numericValue().toDouble()))
+                    else -> throw VmExecutionException("strange abs type ${args[0]}")
+                }
+            }
+            "max" -> {
+                val numbers = args.single().array!!.map { it.toDouble() }
+                RuntimeValue(ArrayElementTypes.getValue(args[0].type), numbers.max())
+            }
+            "min" -> {
+                val numbers = args.single().array!!.map { it.toDouble() }
+                RuntimeValue(ArrayElementTypes.getValue(args[0].type), numbers.min())
+            }
+            "avg" -> {
+                val numbers = args.single().array!!.map { it.toDouble() }
+                RuntimeValue(DataType.FLOAT, numbers.average())
+            }
+            "sum" -> {
+                val sum = args.single().array!!.map { it.toDouble() }.sum()
+                when (args[0].type) {
+                    DataType.ARRAY_UB -> RuntimeValue(DataType.UWORD, sum)
+                    DataType.ARRAY_B -> RuntimeValue(DataType.WORD, sum)
+                    DataType.ARRAY_UW -> RuntimeValue(DataType.UWORD, sum)
+                    DataType.ARRAY_W -> RuntimeValue(DataType.WORD, sum)
+                    DataType.ARRAY_F -> RuntimeValue(DataType.FLOAT, sum)
+                    else -> throw VmExecutionException("weird sum type ${args[0]}")
+                }
+            }
+            "any" -> {
+                val numbers = args.single().array!!.map { it.toDouble() }
+                RuntimeValue(DataType.UBYTE, if (numbers.any { it != 0.0 }) 1 else 0)
+            }
+            "all" -> {
+                val numbers = args.single().array!!.map { it.toDouble() }
+                RuntimeValue(DataType.UBYTE, if (numbers.all { it != 0.0 }) 1 else 0)
+            }
+            "swap" ->
+                throw VmExecutionException("swap() cannot be implemented as a function")
+            "strlen" -> {
+                val zeroIndex = args[0].str!!.indexOf(0.toChar())
+                if (zeroIndex >= 0)
+                    RuntimeValue(DataType.UBYTE, zeroIndex)
+                else
+                    RuntimeValue(DataType.UBYTE, args[0].str!!.length)
+            }
+            "memset" -> {
+                val heapId = args[0].wordval!!
+                val target = program.heap.get(heapId).array ?: throw VmExecutionException("memset target is not an array")
+                val amount = args[1].integerValue()
+                val value = args[2].integerValue()
+                for (i in 0 until amount) {
+                    target[i] = IntegerOrAddressOf(value, null)
+                }
+                null
+            }
+            "memsetw" -> {
+                val heapId = args[0].wordval!!
+                val target = program.heap.get(heapId).array  ?: throw VmExecutionException("memset target is not an array")
+                val amount = args[1].integerValue()
+                val value = args[2].integerValue()
+                for (i in 0 until amount step 2) {
+                    target[i * 2] = IntegerOrAddressOf(value and 255, null)
+                    target[i * 2 + 1] = IntegerOrAddressOf(value ushr 8, null)
+                }
+                null
+            }
+            "memcopy" -> {
+                val sourceHeapId = args[0].wordval!!
+                val destHeapId = args[1].wordval!!
+                val source = program.heap.get(sourceHeapId).array!!
+                val dest = program.heap.get(destHeapId).array!!
+                val amount = args[2].integerValue()
+                for(i in 0 until amount) {
+                    dest[i] = source[i]
+                }
+                null
+            }
+            "mkword" -> {
+                val result = (args[1].integerValue() shl 8) or args[0].integerValue()
+                RuntimeValue(DataType.UWORD, result)
+            }
+            "set_carry" -> {
+                statusflags.carry=true
+                null
+            }
+            "clear_carry" -> {
+                statusflags.carry=false
+                null
+            }
+            "set_irqd" -> {
+                statusflags.irqd=true
+                null
+            }
+            "clear_irqd" -> {
+                statusflags.irqd=false
+                null
+            }
+            "read_flags" -> {
+                val carry = if(statusflags.carry) 1 else 0
+                val zero = if(statusflags.zero) 2 else 0
+                val irqd = if(statusflags.irqd) 4 else 0
+                val negative = if(statusflags.negative) 128 else 0
+                RuntimeValue(DataType.UBYTE, carry or zero or irqd or negative)
+            }
+            "rsave" -> {
+                statusFlagsSave.push(statusflags)
+                registerAsave.push(runtimeVariables.get(program.namespace, Register.A.name))
+                registerXsave.push(runtimeVariables.get(program.namespace, Register.X.name))
+                registerYsave.push(runtimeVariables.get(program.namespace, Register.Y.name))
+                null
+            }
+            "rrestore" -> {
+                val flags = statusFlagsSave.pop()
+                statusflags.carry = flags.carry
+                statusflags.negative = flags.negative
+                statusflags.zero = flags.zero
+                statusflags.irqd = flags.irqd
+                runtimeVariables.set(program.namespace, Register.A.name, registerAsave.pop())
+                runtimeVariables.set(program.namespace, Register.X.name, registerXsave.pop())
+                runtimeVariables.set(program.namespace, Register.Y.name, registerYsave.pop())
+                null
+            }
+            else -> TODO("builtin function $name")
+        }
+    }
+
+}

compiler/src/prog8/vm/astvm/Expressions.kt

@@ -0,0 +1,176 @@
+package prog8.vm.astvm
+
+import prog8.ast.Program
+import prog8.ast.base.ArrayElementTypes
+import prog8.ast.base.DataType
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.VarDeclType
+import prog8.ast.expressions.*
+import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
+import prog8.ast.statements.Label
+import prog8.ast.statements.Subroutine
+import prog8.ast.statements.VarDecl
+import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueRange
+import kotlin.math.abs
+
+
+typealias BuiltinfunctionCaller =  (name: String, args: List<RuntimeValue>, flags: StatusFlags) -> RuntimeValue?
+typealias SubroutineCaller =  (sub: Subroutine, args: List<RuntimeValue>, startAtLabel: Label?) -> RuntimeValue?
+
+
+class EvalContext(val program: Program, val mem: Memory, val statusflags: StatusFlags,
+                  val runtimeVars: RuntimeVariables,
+                  val performBuiltinFunction: BuiltinfunctionCaller,
+                  val executeSubroutine: SubroutineCaller)
+
+fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
+    val constval = expr.constValue(ctx.program)
+    if(constval!=null)
+        return RuntimeValue.fromLv(constval)
+
+    when(expr) {
+        is NumericLiteralValue -> {
+            return RuntimeValue.fromLv(expr)
+        }
+        is ReferenceLiteralValue -> {
+            return RuntimeValue.fromLv(expr, ctx.program.heap)
+        }
+        is PrefixExpression -> {
+            return when(expr.operator) {
+                "-" -> evaluate(expr.expression, ctx).neg()
+                "~" -> evaluate(expr.expression, ctx).inv()
+                "not" -> evaluate(expr.expression, ctx).not()
+                // unary '+' should have been optimized away
+                else -> throw VmExecutionException("unsupported prefix operator "+expr.operator)
+            }
+        }
+        is BinaryExpression -> {
+            val left = evaluate(expr.left, ctx)
+            val right = evaluate(expr.right, ctx)
+            return when(expr.operator) {
+                "<" -> RuntimeValue(DataType.UBYTE, if (left < right) 1 else 0)
+                "<=" -> RuntimeValue(DataType.UBYTE, if (left <= right) 1 else 0)
+                ">" -> RuntimeValue(DataType.UBYTE, if (left > right) 1 else 0)
+                ">=" -> RuntimeValue(DataType.UBYTE, if (left >= right) 1 else 0)
+                "==" -> RuntimeValue(DataType.UBYTE, if (left == right) 1 else 0)
+                "!=" -> RuntimeValue(DataType.UBYTE, if (left != right) 1 else 0)
+                "+" -> left.add(right)
+                "-" -> left.sub(right)
+                "*" -> left.mul(right)
+                "/" -> left.div(right)
+                "**" -> left.pow(right)
+                "<<" -> {
+                    var result = left
+                    repeat(right.integerValue()) {result = result.shl()}
+                    result
+                }
+                ">>" -> {
+                    var result = left
+                    repeat(right.integerValue()) {result = result.shr()}
+                    result
+                }
+                "%" -> left.remainder(right)
+                "|" -> left.bitor(right)
+                "&" -> left.bitand(right)
+                "^" -> left.bitxor(right)
+                "and" -> left.and(right)
+                "or" -> left.or(right)
+                "xor" -> left.xor(right)
+                else -> throw VmExecutionException("unsupported operator "+expr.operator)
+            }
+        }
+        is ArrayIndexedExpression -> {
+            val array = evaluate(expr.identifier, ctx)
+            val index = evaluate(expr.arrayspec.index, ctx)
+            val value = array.array!![index.integerValue()]
+            return RuntimeValue(ArrayElementTypes.getValue(array.type), value)
+        }
+        is TypecastExpression -> {
+            return evaluate(expr.expression, ctx).cast(expr.type)
+        }
+        is AddressOf -> {
+            // we support: address of heap var -> the heap id
+            return try {
+                val heapId = expr.identifier.heapId(ctx.program.namespace)
+                RuntimeValue(DataType.UWORD, heapId)
+            } catch( f: FatalAstException) {
+                // fallback: use the hash of the name, so we have at least *a* value...
+                val address = expr.identifier.hashCode() and 65535
+                RuntimeValue(DataType.UWORD, address)
+            }
+        }
+        is DirectMemoryRead -> {
+            val address = evaluate(expr.addressExpression, ctx).wordval!!
+            return RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
+        }
+        is RegisterExpr -> return ctx.runtimeVars.get(ctx.program.namespace, expr.register.name)
+        is IdentifierReference -> {
+            val scope = expr.definingScope()
+            val variable = scope.lookup(expr.nameInSource, expr)
+            if(variable is VarDecl) {
+                when {
+                    variable.type==VarDeclType.VAR -> return ctx.runtimeVars.get(variable.definingScope(), variable.name)
+                    variable.datatype==DataType.STRUCT -> throw VmExecutionException("cannot process structs by-value.  at ${expr.position}")
+                    else -> {
+                        val address = ctx.runtimeVars.getMemoryAddress(variable.definingScope(), variable.name)
+                        return when(variable.datatype) {
+                            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
+                            DataType.BYTE -> RuntimeValue(DataType.BYTE, ctx.mem.getSByte(address))
+                            DataType.UWORD -> RuntimeValue(DataType.UWORD, ctx.mem.getUWord(address))
+                            DataType.WORD -> RuntimeValue(DataType.WORD, ctx.mem.getSWord(address))
+                            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, ctx.mem.getFloat(address))
+                            DataType.STR -> RuntimeValue(DataType.STR, str = ctx.mem.getString(address))
+                            DataType.STR_S -> RuntimeValue(DataType.STR_S, str = ctx.mem.getScreencodeString(address))
+                            else -> throw VmExecutionException("unexpected datatype $variable")
+                        }
+                    }
+                }
+            } else
+                throw VmExecutionException("weird identifier reference $variable")
+        }
+        is FunctionCall -> {
+            val sub = expr.target.targetStatement(ctx.program.namespace)
+            val args = expr.arglist.map { evaluate(it, ctx) }
+            return when(sub) {
+                is Subroutine -> {
+                    val result = ctx.executeSubroutine(sub, args, null)
+                            ?: throw VmExecutionException("expected a result from functioncall $expr")
+                    result
+                }
+                is BuiltinFunctionStatementPlaceholder -> {
+                    val result = ctx.performBuiltinFunction(sub.name, args, ctx.statusflags)
+                            ?: throw VmExecutionException("expected 1 result from functioncall $expr")
+                    result
+                }
+                else -> {
+                    throw VmExecutionException("unimplemented function call target $sub")
+                }
+            }
+        }
+        is RangeExpr -> {
+            val cRange = expr.toConstantIntegerRange()
+            if(cRange!=null)
+                return RuntimeValueRange(expr.inferType(ctx.program)!!, cRange)
+            val fromVal = evaluate(expr.from, ctx).integerValue()
+            val toVal = evaluate(expr.to, ctx).integerValue()
+            val stepVal = evaluate(expr.step, ctx).integerValue()
+            val range = when {
+                fromVal <= toVal -> when {
+                    stepVal <= 0 -> IntRange.EMPTY
+                    stepVal == 1 -> fromVal..toVal
+                    else -> fromVal..toVal step stepVal
+                }
+                else -> when {
+                    stepVal >= 0 -> IntRange.EMPTY
+                    stepVal == -1 -> fromVal downTo toVal
+                    else -> fromVal downTo toVal step abs(stepVal)
+                }
+            }
+            return RuntimeValueRange(expr.inferType(ctx.program)!!, range)
+        }
+        else -> {
+            throw VmExecutionException("unimplemented expression node $expr")
+        }
+    }
+}

compiler/src/prog8/vm/astvm/Memory.kt

@@ -0,0 +1,144 @@
+package prog8.vm.astvm
+
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.Petscii
+import kotlin.math.abs
+
+class Memory(private val readObserver: (address: Int, value: Short) -> Short,
+             private val writeObserver: (address: Int, value: Short) -> Short)
+{
+
+    private val mem = ShortArray(65536)         // shorts because byte is signed and we store values 0..255
+    private val observed = BooleanArray(65536)     // what addresses are observed
+
+
+    fun observe(vararg address: Int) {
+        address.forEach { observed[it]=true }
+    }
+
+    fun getUByte(address: Int): Short {
+        return if(observed[address]) readObserver(address, mem[address])
+        else mem[address]
+    }
+
+    fun getUByte_DMA(address: Int): Short {
+        return mem[address]
+    }
+
+    fun getSByte(address: Int): Short {
+        val ubyte = getUByte(address)
+        return if(ubyte <= 127) ubyte
+        else (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
+    }
+
+    fun setUByte(address: Int, value: Short) {
+        if(value !in 0..255)
+            throw VmExecutionException("ubyte value out of range $value")
+        mem[address] =
+                if(observed[address]) writeObserver(address, value)
+                else value
+    }
+
+    fun setUByte_DMA(address: Int, value: Short) {
+        if(value !in 0..255)
+            throw VmExecutionException("ubyte value out of range $value")
+        mem[address] = value
+    }
+
+    fun setSByte(address: Int, value: Short) {
+        if(value !in -128..127) throw VmExecutionException("byte value out of range $value")
+        val ubyte =
+                if(value>=0) value
+                else ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
+        setUByte(address, ubyte)
+    }
+
+    fun getUWord(address: Int): Int {
+        return getUByte(address) + 256*getUByte(address+1)
+    }
+
+    fun getSWord(address: Int): Int {
+        val uword = getUWord(address)
+        if(uword <= 32767)
+            return uword
+        return -((uword xor 65535)+1)   // 2's complement
+    }
+
+    fun setUWord(address: Int, value: Int) {
+        if(value !in 0..65535)
+            throw VmExecutionException("uword value out of range $value")
+        setUByte(address, value.and(255).toShort())
+        setUByte(address+1, (value / 256).toShort())
+    }
+
+    fun setSWord(address: Int, value: Int) {
+        if(value !in -32768..32767) throw VmExecutionException("word value out of range $value")
+        if(value>=0)
+            setUWord(address, value)
+        else
+            setUWord(address, (abs(value) xor 65535)+1)        // 2's complement
+    }
+
+    fun setFloat(address: Int, value: Double) {
+        val mflpt5 = MachineDefinition.Mflpt5.fromNumber(value)
+        setUByte(address, mflpt5.b0)
+        setUByte(address+1, mflpt5.b1)
+        setUByte(address+2, mflpt5.b2)
+        setUByte(address+3, mflpt5.b3)
+        setUByte(address+4, mflpt5.b4)
+    }
+
+    fun getFloat(address: Int): Double {
+        return MachineDefinition.Mflpt5(getUByte(address), getUByte(address + 1), getUByte(address + 2),
+                getUByte(address + 3), getUByte(address + 4)).toDouble()
+    }
+
+    fun setString(address: Int, str: String) {
+        // lowercase PETSCII
+        val petscii = Petscii.encodePetscii(str, true)
+        var addr = address
+        for (c in petscii) setUByte(addr++, c)
+        setUByte(addr, 0)
+    }
+
+    fun getString(strAddress: Int): String {
+        // lowercase PETSCII
+        val petscii = mutableListOf<Short>()
+        var addr = strAddress
+        while(true) {
+            val byte = getUByte(addr++)
+            if(byte==0.toShort()) break
+            petscii.add(byte)
+        }
+        return Petscii.decodePetscii(petscii, true)
+    }
+
+    fun clear() {
+        for(i in 0..65535) setUByte(i, 0)
+    }
+
+    fun copy(from: Int, to: Int, numbytes: Int) {
+        for(i in 0 until numbytes)
+            setUByte(to+i, getUByte(from+i))
+    }
+
+    fun getScreencodeString(strAddress: Int): String? {
+        // lowercase Screencodes
+        val screencodes = mutableListOf<Short>()
+        var addr = strAddress
+        while(true) {
+            val byte = getUByte(addr++)
+            if(byte==0.toShort()) break
+            screencodes.add(byte)
+        }
+        return Petscii.decodeScreencode(screencodes, true)
+    }
+
+    fun setScreencodeString(address: Int, str: String) {
+        // lowercase screencodes
+        val screencodes = Petscii.encodeScreencode(str, true)
+        var addr = address
+        for (c in screencodes) setUByte(addr++, c)
+        setUByte(addr, 0)
+    }
+}

compiler/src/prog8/vm/astvm/ScreenDialog.kt

@@ -1,11 +1,12 @@
-package prog8.stackvm
+package prog8.vm.astvm
 
-import prog8.compiler.target.c64.Charset
+import prog8.compiler.target.c64.MachineDefinition
 import prog8.compiler.target.c64.Petscii
 import java.awt.*
 import java.awt.event.KeyEvent
 import java.awt.event.KeyListener
 import java.awt.image.BufferedImage
+import java.util.*
 import javax.swing.JFrame
 import javax.swing.JPanel
 import javax.swing.Timer
@@ -17,6 +18,7 @@ class BitmapScreenPanel : KeyListener, JPanel() {
     private val g2d = image.graphics as Graphics2D
     private var cursorX: Int=0
     private var cursorY: Int=0
+    val keyboardBuffer: Deque<Char> = LinkedList()
 
     init {
         val size = Dimension(image.width * SCALING, image.height * SCALING)
@@ -29,14 +31,14 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         addKeyListener(this)
     }
 
-    override fun keyTyped(p0: KeyEvent?) {}
+    override fun keyTyped(p0: KeyEvent) {
+        keyboardBuffer.add(p0.keyChar)
+    }
 
-    override fun keyPressed(p0: KeyEvent?) {
-        println("pressed: $p0.k")
+    override fun keyPressed(p0: KeyEvent) {
     }
 
     override fun keyReleased(p0: KeyEvent?) {
-        println("released: $p0")
     }
 
     override fun paint(graphics: Graphics?) {
@@ -47,63 +49,84 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         g2d.drawImage(image, 0, 0, image.width * 3, image.height * 3, null)
     }
 
-    fun clearScreen(color: Int) {
-        g2d.background = palette[color and 15]
-        g2d.clearRect(0, 0, BitmapScreenPanel.SCREENWIDTH, BitmapScreenPanel.SCREENHEIGHT)
+    fun clearScreen(color: Short) {
+        g2d.background = MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size]
+        g2d.clearRect(0, 0, SCREENWIDTH, SCREENHEIGHT)
         cursorX = 0
         cursorY = 0
     }
-    fun setPixel(x: Int, y: Int, color: Int) {
-        image.setRGB(x, y, palette[color and 15].rgb)
+    fun setPixel(x: Int, y: Int, color: Short) {
+        image.setRGB(x, y, MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size].rgb)
     }
-    fun drawLine(x1: Int, y1: Int, x2: Int, y2: Int, color: Int) {
-        g2d.color = palette[color and 15]
+    fun drawLine(x1: Int, y1: Int, x2: Int, y2: Int, color: Short) {
+        g2d.color = MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size]
         g2d.drawLine(x1, y1, x2, y2)
     }
-    fun printText(text: String, color: Int, lowercase: Boolean) {
-        val lines = text.split('\n')
+
+    fun printText(text: String, lowercase: Boolean, inverseVideo: Boolean=false) {
+        val t2 = text.substringBefore(0.toChar())
+        val lines = t2.split('\n')
         for(line in lines.withIndex()) {
-            printTextSingleLine(line.value, color, lowercase)
+            val petscii = Petscii.encodePetscii(line.value, lowercase)
+            petscii.forEach { printPetscii(it, inverseVideo) }
             if(line.index<lines.size-1) {
-                cursorX=0
-                cursorY++
-            }
-        }
-    }
-    private fun printTextSingleLine(text: String, color: Int, lowercase: Boolean) {
-        if(color!=1) {
-            TODO("text can only be white for now")
-        }
-        for(clearx in cursorX until cursorX+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            setChar(cursorX, cursorY, sc)
-            cursorX++
-            if(cursorX>=(SCREENWIDTH/8)) {
-                cursorY++
-                cursorX=0
+                printPetscii(13)    // newline
             }
         }
     }
 
-    fun printChar(char: Short) {
+    fun printPetscii(char: Short, inverseVideo: Boolean=false) {
         if(char==13.toShort() || char==141.toShort()) {
             cursorX=0
             cursorY++
         } else {
-            setChar(cursorX, cursorY, char)
+            setPetscii(cursorX, cursorY, char, 1, inverseVideo)
             cursorX++
             if (cursorX >= (SCREENWIDTH / 8)) {
                 cursorY++
                 cursorX = 0
             }
         }
+        while(cursorY>=(SCREENHEIGHT/8)) {
+            // scroll the screen up because the cursor went past the last line
+            Thread.sleep(10)
+            val screen = image.copy()
+            val graphics = image.graphics as Graphics2D
+            graphics.drawImage(screen, 0, -8, null)
+            val color = graphics.color
+            graphics.color = MachineDefinition.colorPalette[6]
+            graphics.fillRect(0, 24*8, SCREENWIDTH, 25*8)
+            graphics.color=color
+            cursorY--
+        }
     }
 
-    fun setChar(x: Int, y: Int, screenCode: Short) {
+    fun writeTextAt(x: Int, y: Int, text: String, color: Short, lowercase: Boolean, inverseVideo: Boolean=false) {
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        var xx=x
+        for(clearx in xx until xx+text.length) {
+            g2d.clearRect(8*clearx, 8*y, 8, 8)
+        }
+        for(sc in Petscii.encodePetscii(text, lowercase)) {
+            if(sc==0.toShort())
+                break
+            setPetscii(xx++, y, sc, colorIdx, inverseVideo)
+        }
+    }
+
+    fun setPetscii(x: Int, y: Int, petscii: Short, color: Short, inverseVideo: Boolean) {
         g2d.clearRect(8*x, 8*y, 8, 8)
-        g2d.drawImage(Charset.shiftedChars[screenCode.toInt()], 8*x, 8*y , null)
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        val screencode = Petscii.petscii2scr(petscii, inverseVideo)
+        val coloredImage = MachineDefinition.Charset.getColoredChar(screencode, colorIdx)
+        g2d.drawImage(coloredImage, 8*x, 8*y , null)
+    }
+
+    fun setChar(x: Int, y: Int, screencode: Short, color: Short) {
+        g2d.clearRect(8*x, 8*y, 8, 8)
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        val coloredImage = MachineDefinition.Charset.getColoredChar(screencode, colorIdx)
+        g2d.drawImage(coloredImage, 8*x, 8*y , null)
     }
 
     fun setCursorPos(x: Int, y: Int) {
@@ -115,72 +138,40 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         return Pair(cursorX, cursorY)
     }
 
-    fun writeText(x: Int, y: Int, text: String, color: Int, lowercase: Boolean) {
-        var xx=x
-        if(color!=1) {
-            TODO("text can only be white for now")
-        }
-        for(clearx in xx until xx+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            setChar(xx++, y, sc)
-        }
-    }
-
-
     companion object {
         const val SCREENWIDTH = 320
         const val SCREENHEIGHT = 200
         const val SCALING = 3
-        val palette = listOf(         // this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
-                Color(0x000000),  // 0 = black
-                Color(0xFFFFFF),  // 1 = white
-                Color(0x813338),  // 2 = red
-                Color(0x75cec8),  // 3 = cyan
-                Color(0x8e3c97),  // 4 = purple
-                Color(0x56ac4d),  // 5 = green
-                Color(0x2e2c9b),  // 6 = blue
-                Color(0xedf171),  // 7 = yellow
-                Color(0x8e5029),  // 8 = orange
-                Color(0x553800),  // 9 = brown
-                Color(0xc46c71),  // 10 = light red
-                Color(0x4a4a4a),  // 11 = dark grey
-                Color(0x7b7b7b),  // 12 = medium grey
-                Color(0xa9ff9f),  // 13 = light green
-                Color(0x706deb),  // 14 = light blue
-                Color(0xb2b2b2)   // 15 = light grey
-        )
     }
 }
 
 
-class ScreenDialog : JFrame() {
+class ScreenDialog(title: String) : JFrame(title) {
     val canvas = BitmapScreenPanel()
+    val keyboardBuffer = canvas.keyboardBuffer
 
     init {
         val borderWidth = 16
-        title = "StackVm graphics. Text I/O goes to console."
         layout = GridBagLayout()
-        defaultCloseOperation = JFrame.EXIT_ON_CLOSE
+        defaultCloseOperation = EXIT_ON_CLOSE
         isResizable = false
 
         // the borders (top, left, right, bottom)
         val borderTop = JPanel().apply {
-            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = BitmapScreenPanel.palette[14]
+            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
+            background = MachineDefinition.colorPalette[14]
         }
         val borderBottom = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = BitmapScreenPanel.palette[14]
+            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
+            background = MachineDefinition.colorPalette[14]
         }
         val borderLeft = JPanel().apply {
             preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = BitmapScreenPanel.palette[14]
+            background = MachineDefinition.colorPalette[14]
         }
         val borderRight = JPanel().apply {
             preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = BitmapScreenPanel.palette[14]
+            background = MachineDefinition.colorPalette[14]
         }
         var c = GridBagConstraints()
         c.gridx=0; c.gridy=1; c.gridwidth=3
@@ -207,3 +198,12 @@ class ScreenDialog : JFrame() {
         repaintTimer.start()
     }
 }
+
+
+private fun BufferedImage.copy(): BufferedImage {
+    val bcopy = BufferedImage(this.width, this.height, this.type)
+    val g = bcopy.graphics
+    g.drawImage(this, 0, 0, null)
+    g.dispose()
+    return bcopy
+}

compiler/src/prog8/vm/astvm/VariablesCreator.kt

@@ -0,0 +1,77 @@
+package prog8.vm.astvm
+
+import prog8.ast.Program
+import prog8.ast.base.DataType
+import prog8.ast.base.Position
+import prog8.ast.base.Register
+import prog8.ast.base.VarDeclType
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.Statement
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.VarDecl
+import prog8.ast.statements.ZeropageWish
+import prog8.compiler.HeapValues
+import prog8.vm.RuntimeValue
+
+class VariablesCreator(private val runtimeVariables: RuntimeVariables, private val heap: HeapValues) : IAstModifyingVisitor {
+
+    override fun visit(program: Program) {
+        // define the three registers as global variables
+        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValue(DataType.UBYTE, 0))
+        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValue(DataType.UBYTE, 255))
+        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValue(DataType.UBYTE, 0))
+
+        val globalpos = Position("<<global>>", 0, 0, 0)
+        val vdA = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.A.name, null,
+                NumericLiteralValue.optimalInteger(0, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
+        val vdX = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.X.name, null,
+                NumericLiteralValue.optimalInteger(255, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
+        val vdY = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.Y.name, null,
+                NumericLiteralValue.optimalInteger(0, globalpos), isArray = false, autogeneratedDontRemove = true, position = globalpos)
+        vdA.linkParents(program.namespace)
+        vdX.linkParents(program.namespace)
+        vdY.linkParents(program.namespace)
+        program.namespace.statements.add(vdA)
+        program.namespace.statements.add(vdX)
+        program.namespace.statements.add(vdY)
+
+        super.visit(program)
+    }
+
+    override fun visit(decl: VarDecl): Statement {
+        // if the decl is part of a struct, just skip it
+        if(decl.parent !is StructDecl) {
+            when (decl.type) {
+                VarDeclType.VAR -> {
+                    if(decl.datatype!=DataType.STRUCT) {
+                        val numericLv = decl.value as? NumericLiteralValue
+                        val value = if(numericLv!=null) {
+                            RuntimeValue.fromLv(numericLv)
+                        } else {
+                            val referenceLv = decl.value as ReferenceLiteralValue
+                            RuntimeValue.fromLv(referenceLv, heap)
+                        }
+                        runtimeVariables.define(decl.definingScope(), decl.name, value)
+                    }
+                }
+                VarDeclType.MEMORY -> {
+                    runtimeVariables.defineMemory(decl.definingScope(), decl.name, (decl.value as NumericLiteralValue).number.toInt())
+                }
+                VarDeclType.CONST -> {
+                    // consts should have been const-folded away
+                }
+            }
+        }
+        return super.visit(decl)
+    }
+
+//    override fun accept(assignment: Assignment): Statement {
+//        if(assignment is VariableInitializationAssignment) {
+//            println("INIT VAR $assignment")
+//        }
+//        return super.accept(assignment)
+//    }
+
+}

compiler/test/LiteralValueTests.kt

@@ -0,0 +1,145 @@
+package prog8tests
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import prog8.ast.base.DataType
+import prog8.ast.base.Position
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.ReferenceLiteralValue
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+
+
+private fun sameValueAndType(lv1: NumericLiteralValue, lv2: NumericLiteralValue): Boolean {
+    return lv1.type==lv2.type && lv1==lv2
+}
+
+private fun sameValueAndType(rv1: ReferenceLiteralValue, rv2: ReferenceLiteralValue): Boolean {
+    return rv1.type==rv2.type && rv1==rv2
+}
+
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestParserNumericLiteralValue {
+
+    private val dummyPos = Position("test", 0, 0, 0)
+
+    @Test
+    fun testIdentity() {
+        val v = NumericLiteralValue(DataType.UWORD, 12345, dummyPos)
+        assertEquals(v, v)
+        assertFalse(v != v)
+        assertTrue(v <= v)
+        assertTrue(v >= v)
+        assertFalse(v < v)
+        assertFalse(v > v)
+
+        assertTrue(sameValueAndType(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.UWORD, 12345, dummyPos)))
+    }
+
+    @Test
+    fun testEqualsAndNotEquals() {
+        assertEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UWORD, 100, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.UWORD, 254, dummyPos), NumericLiteralValue(DataType.UBYTE, 254, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.UWORD, 12345, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.FLOAT, 12345.0, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos), NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.FLOAT, 22239.0, dummyPos), NumericLiteralValue(DataType.UWORD, 22239, dummyPos))
+        assertEquals(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos))
+
+        assertTrue(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UBYTE, 100, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UWORD, 100, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UWORD, 254, dummyPos), NumericLiteralValue(DataType.UBYTE, 254, dummyPos)))
+        assertTrue(sameValueAndType(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.UWORD, 12345, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.FLOAT, 12345.0, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos), NumericLiteralValue(DataType.UBYTE, 100, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 22239.0, dummyPos), NumericLiteralValue(DataType.UWORD, 22239, dummyPos)))
+        assertTrue(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos)))
+
+        assertNotEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UBYTE, 101, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UWORD, 101, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.FLOAT, 101.0, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.UWORD, 245, dummyPos), NumericLiteralValue(DataType.UBYTE, 246, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.UWORD, 12346, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.FLOAT, 12346.0, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.UBYTE, 9, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.UWORD, 9, dummyPos))
+        assertNotEquals(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.FLOAT, 9.0, dummyPos))
+
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UBYTE, 101, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.UWORD, 101, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UBYTE, 100, dummyPos), NumericLiteralValue(DataType.FLOAT, 101.0, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UWORD, 245, dummyPos), NumericLiteralValue(DataType.UBYTE, 246, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.UWORD, 12346, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.UWORD, 12345, dummyPos), NumericLiteralValue(DataType.FLOAT, 12346.0, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.UBYTE, 9, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.UWORD, 9, dummyPos)))
+        assertFalse(sameValueAndType(NumericLiteralValue(DataType.FLOAT, 9.99, dummyPos), NumericLiteralValue(DataType.FLOAT, 9.0, dummyPos)))
+
+
+    }
+
+    @Test
+    fun testEqualsRef() {
+        assertTrue(sameValueAndType(ReferenceLiteralValue(DataType.STR, str = "hello", position = dummyPos), ReferenceLiteralValue(DataType.STR, str = "hello", position = dummyPos)))
+        assertFalse(sameValueAndType(ReferenceLiteralValue(DataType.STR, str = "hello", position = dummyPos), ReferenceLiteralValue(DataType.STR, str = "bye", position = dummyPos)))
+
+        val lvOne = NumericLiteralValue(DataType.UBYTE, 1, dummyPos)
+        val lvTwo = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
+        val lvThree = NumericLiteralValue(DataType.UBYTE, 3, dummyPos)
+        val lvOneR = NumericLiteralValue(DataType.UBYTE, 1, dummyPos)
+        val lvTwoR = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
+        val lvThreeR = NumericLiteralValue(DataType.UBYTE, 3, dummyPos)
+        val lvFour= NumericLiteralValue(DataType.UBYTE, 4, dummyPos)
+        val lv1 = ReferenceLiteralValue(DataType.ARRAY_UB, array = arrayOf(lvOne, lvTwo, lvThree), position = dummyPos)
+        val lv2 = ReferenceLiteralValue(DataType.ARRAY_UB, array = arrayOf(lvOneR, lvTwoR, lvThreeR), position = dummyPos)
+        val lv3 = ReferenceLiteralValue(DataType.ARRAY_UB, array = arrayOf(lvOneR, lvTwoR, lvFour), position = dummyPos)
+        assertEquals(lv1, lv2)
+        assertNotEquals(lv1, lv3)
+    }
+
+    @Test
+    fun testGreaterThan(){
+        assertTrue(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) > NumericLiteralValue(DataType.UBYTE, 99, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.UWORD, 254, dummyPos) > NumericLiteralValue(DataType.UWORD, 253, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) > NumericLiteralValue(DataType.FLOAT, 99.9, dummyPos))
+
+        assertTrue(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) >= NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.UWORD, 254, dummyPos) >= NumericLiteralValue(DataType.UWORD, 254, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) >= NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos))
+
+        assertFalse(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) > NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.UWORD, 254, dummyPos) > NumericLiteralValue(DataType.UWORD, 254, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) > NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos))
+
+        assertFalse(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) >= NumericLiteralValue(DataType.UBYTE, 101, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.UWORD, 254, dummyPos) >= NumericLiteralValue(DataType.UWORD, 255, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) >= NumericLiteralValue(DataType.FLOAT, 100.1, dummyPos))
+    }
+
+    @Test
+    fun testLessThan() {
+        assertTrue(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) < NumericLiteralValue(DataType.UBYTE, 101, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.UWORD, 254, dummyPos) < NumericLiteralValue(DataType.UWORD, 255, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) < NumericLiteralValue(DataType.FLOAT, 100.1, dummyPos))
+
+        assertTrue(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) <= NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.UWORD, 254, dummyPos) <= NumericLiteralValue(DataType.UWORD, 254, dummyPos))
+        assertTrue(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) <= NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos))
+
+        assertFalse(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) < NumericLiteralValue(DataType.UBYTE, 100, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.UWORD, 254, dummyPos) < NumericLiteralValue(DataType.UWORD, 254, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) < NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos))
+
+        assertFalse(NumericLiteralValue(DataType.UBYTE, 100, dummyPos) <= NumericLiteralValue(DataType.UBYTE, 99, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.UWORD, 254, dummyPos) <= NumericLiteralValue(DataType.UWORD, 253, dummyPos))
+        assertFalse(NumericLiteralValue(DataType.FLOAT, 100.0, dummyPos) <= NumericLiteralValue(DataType.FLOAT, 99.9, dummyPos))
+    }
+
+}
+

compiler/test/RuntimeValueTests.kt

@@ -0,0 +1,369 @@
+package prog8tests
+
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import prog8.ast.base.DataType
+import prog8.vm.RuntimeValue
+import kotlin.test.*
+
+
+private fun sameValueAndType(v1: RuntimeValue, v2: RuntimeValue): Boolean {
+    return v1.type==v2.type && v1==v2
+}
+
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TestRuntimeValue {
+
+    @Test
+    fun testValueRanges() {
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 255).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UBYTE, -1)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UBYTE, 256)}
+
+        assertEquals(0, RuntimeValue(DataType.BYTE, 0).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -128).integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, 127).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.BYTE, -129)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.BYTE, 128)}
+
+        assertEquals(0, RuntimeValue(DataType.UWORD, 0).integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 65535).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UWORD, -1)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UWORD, 65536)}
+
+        assertEquals(0, RuntimeValue(DataType.WORD, 0).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32768).integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32767).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.WORD, -32769)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.WORD, 32768)}
+    }
+
+    @Test
+    fun testTruthiness()
+    {
+        assertFalse(RuntimeValue(DataType.BYTE, 0).asBoolean)
+        assertFalse(RuntimeValue(DataType.UBYTE, 0).asBoolean)
+        assertFalse(RuntimeValue(DataType.WORD, 0).asBoolean)
+        assertFalse(RuntimeValue(DataType.UWORD, 0).asBoolean)
+        assertFalse(RuntimeValue(DataType.FLOAT, 0.0).asBoolean)
+
+        assertTrue(RuntimeValue(DataType.BYTE, 42).asBoolean)
+        assertTrue(RuntimeValue(DataType.UBYTE, 42).asBoolean)
+        assertTrue(RuntimeValue(DataType.WORD, 42).asBoolean)
+        assertTrue(RuntimeValue(DataType.UWORD, 42).asBoolean)
+        assertTrue(RuntimeValue(DataType.FLOAT, 42.0).asBoolean)
+        assertTrue(RuntimeValue(DataType.BYTE, -42).asBoolean)
+        assertTrue(RuntimeValue(DataType.WORD, -42).asBoolean)
+        assertTrue(RuntimeValue(DataType.FLOAT, -42.0).asBoolean)
+    }
+
+
+    @Test
+    fun testIdentity() {
+        val v = RuntimeValue(DataType.UWORD, 12345)
+        assertEquals(v, v)
+        assertFalse(v != v)
+        assertTrue(v<=v)
+        assertTrue(v>=v)
+        assertFalse(v<v)
+        assertFalse(v>v)
+
+        assertTrue(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UBYTE, 100)))
+    }
+
+    @Test
+    fun testEqualsAndNotEquals() {
+        assertEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UBYTE, 100))
+        assertEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UWORD, 100))
+        assertEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.FLOAT, 100))
+        assertEquals(RuntimeValue(DataType.UWORD, 254), RuntimeValue(DataType.UBYTE, 254))
+        assertEquals(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.UWORD, 12345))
+        assertEquals(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.FLOAT, 12345))
+        assertEquals(RuntimeValue(DataType.FLOAT, 100.0), RuntimeValue(DataType.UBYTE, 100))
+        assertEquals(RuntimeValue(DataType.FLOAT, 22239.0), RuntimeValue(DataType.UWORD, 22239))
+        assertEquals(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.FLOAT, 9.99))
+
+        assertTrue(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UBYTE, 100)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UWORD, 100)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.FLOAT, 100)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UWORD, 254), RuntimeValue(DataType.UBYTE, 254)))
+        assertTrue(sameValueAndType(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.UWORD, 12345)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.FLOAT, 12345)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 100.0), RuntimeValue(DataType.UBYTE, 100)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 22239.0), RuntimeValue(DataType.UWORD, 22239)))
+        assertTrue(sameValueAndType(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.FLOAT, 9.99)))
+
+        assertNotEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UBYTE, 101))
+        assertNotEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UWORD, 101))
+        assertNotEquals(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.FLOAT, 101))
+        assertNotEquals(RuntimeValue(DataType.UWORD, 245), RuntimeValue(DataType.UBYTE, 246))
+        assertNotEquals(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.UWORD, 12346))
+        assertNotEquals(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.FLOAT, 12346))
+        assertNotEquals(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.UBYTE, 9))
+        assertNotEquals(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.UWORD, 9))
+        assertNotEquals(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.FLOAT, 9.0))
+
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UBYTE, 101)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.UWORD, 101)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UBYTE, 100), RuntimeValue(DataType.FLOAT, 101)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UWORD, 245), RuntimeValue(DataType.UBYTE, 246)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.UWORD, 12346)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.UWORD, 12345), RuntimeValue(DataType.FLOAT, 12346)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.UBYTE, 9)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.UWORD, 9)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.FLOAT, 9.0)))
+    }
+
+    @Test
+    fun testEqualityHeapTypes()
+    {
+        assertTrue(sameValueAndType(RuntimeValue(DataType.STR, heapId = 999), RuntimeValue(DataType.STR, heapId = 999)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.STR, heapId = 999), RuntimeValue(DataType.STR, heapId = 222)))
+
+        assertTrue(sameValueAndType(RuntimeValue(DataType.ARRAY_UB, heapId = 99), RuntimeValue(DataType.ARRAY_UB, heapId = 99)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.ARRAY_UB, heapId = 99), RuntimeValue(DataType.ARRAY_UB, heapId = 22)))
+
+        assertTrue(sameValueAndType(RuntimeValue(DataType.ARRAY_UW, heapId = 999), RuntimeValue(DataType.ARRAY_UW, heapId = 999)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.ARRAY_UW, heapId = 999), RuntimeValue(DataType.ARRAY_UW, heapId = 222)))
+
+        assertTrue(sameValueAndType(RuntimeValue(DataType.ARRAY_F, heapId = 999), RuntimeValue(DataType.ARRAY_F, heapId = 999)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.ARRAY_F, heapId = 999), RuntimeValue(DataType.ARRAY_UW, heapId = 999)))
+        assertFalse(sameValueAndType(RuntimeValue(DataType.ARRAY_F, heapId = 999), RuntimeValue(DataType.ARRAY_F, heapId = 222)))
+    }
+
+    @Test
+    fun testGreaterThan(){
+        assertTrue(RuntimeValue(DataType.UBYTE, 100) > RuntimeValue(DataType.UBYTE, 99))
+        assertTrue(RuntimeValue(DataType.UWORD, 254) > RuntimeValue(DataType.UWORD, 253))
+        assertTrue(RuntimeValue(DataType.FLOAT, 100.0) > RuntimeValue(DataType.FLOAT, 99.9))
+
+        assertTrue(RuntimeValue(DataType.UBYTE, 100) >= RuntimeValue(DataType.UBYTE, 100))
+        assertTrue(RuntimeValue(DataType.UWORD, 254) >= RuntimeValue(DataType.UWORD, 254))
+        assertTrue(RuntimeValue(DataType.FLOAT, 100.0) >= RuntimeValue(DataType.FLOAT, 100.0))
+
+        assertFalse(RuntimeValue(DataType.UBYTE, 100) > RuntimeValue(DataType.UBYTE, 100))
+        assertFalse(RuntimeValue(DataType.UWORD, 254) > RuntimeValue(DataType.UWORD, 254))
+        assertFalse(RuntimeValue(DataType.FLOAT, 100.0) > RuntimeValue(DataType.FLOAT, 100.0))
+
+        assertFalse(RuntimeValue(DataType.UBYTE, 100) >= RuntimeValue(DataType.UBYTE, 101))
+        assertFalse(RuntimeValue(DataType.UWORD, 254) >= RuntimeValue(DataType.UWORD, 255))
+        assertFalse(RuntimeValue(DataType.FLOAT, 100.0) >= RuntimeValue(DataType.FLOAT, 100.1))
+    }
+
+    @Test
+    fun testLessThan() {
+        assertTrue(RuntimeValue(DataType.UBYTE, 100) < RuntimeValue(DataType.UBYTE, 101))
+        assertTrue(RuntimeValue(DataType.UWORD, 254) < RuntimeValue(DataType.UWORD, 255))
+        assertTrue(RuntimeValue(DataType.FLOAT, 100.0) < RuntimeValue(DataType.FLOAT, 100.1))
+
+        assertTrue(RuntimeValue(DataType.UBYTE, 100) <= RuntimeValue(DataType.UBYTE, 100))
+        assertTrue(RuntimeValue(DataType.UWORD, 254) <= RuntimeValue(DataType.UWORD, 254))
+        assertTrue(RuntimeValue(DataType.FLOAT, 100.0) <= RuntimeValue(DataType.FLOAT, 100.0))
+
+        assertFalse(RuntimeValue(DataType.UBYTE, 100) < RuntimeValue(DataType.UBYTE, 100))
+        assertFalse(RuntimeValue(DataType.UWORD, 254) < RuntimeValue(DataType.UWORD, 254))
+        assertFalse(RuntimeValue(DataType.FLOAT, 100.0) < RuntimeValue(DataType.FLOAT, 100.0))
+
+        assertFalse(RuntimeValue(DataType.UBYTE, 100) <= RuntimeValue(DataType.UBYTE, 99))
+        assertFalse(RuntimeValue(DataType.UWORD, 254) <= RuntimeValue(DataType.UWORD, 253))
+        assertFalse(RuntimeValue(DataType.FLOAT, 100.0) <= RuntimeValue(DataType.FLOAT, 99.9))
+    }
+
+    @Test
+    fun testNoDtConversion() {
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UWORD, 100).add(RuntimeValue(DataType.UBYTE, 120))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UBYTE, 100).add(RuntimeValue(DataType.UWORD, 120))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.FLOAT, 100.22).add(RuntimeValue(DataType.UWORD, 120))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UWORD, 1002).add(RuntimeValue(DataType.FLOAT, 120.22))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.FLOAT, 100.22).add(RuntimeValue(DataType.UBYTE, 120))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UBYTE, 12).add(RuntimeValue(DataType.FLOAT, 120.22))
+        }
+    }
+
+    @Test
+    fun testNoAutoFloatConversion() {
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UBYTE, 233).add(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UWORD, 233).add(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UBYTE, 233).mul(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UWORD, 233).mul(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UBYTE, 233).div(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        assertFailsWith<ArithmeticException> {
+            RuntimeValue(DataType.UWORD, 233).div(RuntimeValue(DataType.FLOAT, 1.234))
+        }
+        val result = RuntimeValue(DataType.FLOAT, 233.333).add(RuntimeValue(DataType.FLOAT, 1.234))
+    }
+
+    @Test
+    fun arithmetictestUbyte() {
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 55)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 56)).integerValue())
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 57)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 2)).integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 3)).integerValue())
+
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 254).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 255).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 1).dec().integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 0).dec().integerValue())
+
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 0).inv().integerValue())
+        assertEquals(0b00110011, RuntimeValue(DataType.UBYTE, 0b11001100).inv().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).neg().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 255).not().integerValue())
+
+        assertEquals(200, RuntimeValue(DataType.UBYTE, 20).mul(RuntimeValue(DataType.UBYTE, 10)).integerValue())
+        assertEquals(144, RuntimeValue(DataType.UBYTE, 20).mul(RuntimeValue(DataType.UBYTE, 20)).integerValue())
+
+        assertEquals(25, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 2)).integerValue())
+        assertEquals(125, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 3)).integerValue())
+        assertEquals(113, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 4)).integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.UBYTE, 50).shl().integerValue())
+        assertEquals(200, RuntimeValue(DataType.UBYTE, 100).shl().integerValue())
+        assertEquals(144, RuntimeValue(DataType.UBYTE, 200).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestUWord() {
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5535)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5536)).integerValue())
+        assertEquals(1, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5537)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 2)).integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 3)).integerValue())
+
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 65534).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 65535).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 1).dec().integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 0).dec().integerValue())
+
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 0).inv().integerValue())
+        assertEquals(0b0011001101010101, RuntimeValue(DataType.UWORD, 0b1100110010101010).inv().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UWORD, 0).neg().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UWORD, 0).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.UWORD, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 11111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 65535).not().integerValue())
+
+        assertEquals(2000, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 10)).integerValue())
+        assertEquals(40000, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 200)).integerValue())
+        assertEquals(14464, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 400)).integerValue())
+
+        assertEquals(15625, RuntimeValue(DataType.UWORD, 5).pow(RuntimeValue(DataType.UWORD, 6)).integerValue())
+        assertEquals(12589, RuntimeValue(DataType.UWORD, 5).pow(RuntimeValue(DataType.UWORD, 7)).integerValue())
+
+        assertEquals(10000, RuntimeValue(DataType.UWORD, 5000).shl().integerValue())
+        assertEquals(60000, RuntimeValue(DataType.UWORD, 30000).shl().integerValue())
+        assertEquals(14464, RuntimeValue(DataType.UWORD, 40000).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestByte() {
+        assertEquals(127, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 27)).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 28)).integerValue())
+        assertEquals(-127, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 29)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 2)).integerValue())
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 3)).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -100).sub(RuntimeValue(DataType.BYTE, 28)).integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, -100).sub(RuntimeValue(DataType.BYTE, 29)).integerValue())
+
+        assertEquals(127, RuntimeValue(DataType.BYTE, 126).inc().integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, 127).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 1).dec().integerValue())
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 0).dec().integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -127).dec().integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, -128).dec().integerValue())
+
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 0).inv().integerValue())
+        assertEquals(-103, RuntimeValue(DataType.BYTE, 0b01100110).inv().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 0).neg().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.BYTE, 2).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.BYTE, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, -33).not().integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.BYTE, 10).mul(RuntimeValue(DataType.BYTE, 10)).integerValue())
+        assertEquals(-56, RuntimeValue(DataType.BYTE, 20).mul(RuntimeValue(DataType.BYTE, 10)).integerValue())
+
+        assertEquals(25, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 2)).integerValue())
+        assertEquals(125, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 3)).integerValue())
+        assertEquals(113, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 4)).integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.BYTE, 50).shl().integerValue())
+        assertEquals(-56, RuntimeValue(DataType.BYTE, 100).shl().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.BYTE, -1).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestWorrd() {
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 67)).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 68)).integerValue())
+        assertEquals(-32767, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 69)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 2)).integerValue())
+        assertEquals(-1, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 3)).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32700).sub(RuntimeValue(DataType.WORD, 68)).integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, -32700).sub(RuntimeValue(DataType.WORD, 69)).integerValue())
+
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32766).inc().integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, 32767).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 1).dec().integerValue())
+        assertEquals(-1, RuntimeValue(DataType.WORD, 0).dec().integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32767).dec().integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, -32768).dec().integerValue())
+
+        assertEquals(-1, RuntimeValue(DataType.WORD, 0).inv().integerValue())
+        assertEquals(-103, RuntimeValue(DataType.WORD, 0b01100110).inv().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 0).neg().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.WORD, 2).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.WORD, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, -33).not().integerValue())
+
+        assertEquals(10000, RuntimeValue(DataType.WORD, 100).mul(RuntimeValue(DataType.WORD, 100)).integerValue())
+        assertEquals(-25536, RuntimeValue(DataType.WORD, 200).mul(RuntimeValue(DataType.WORD, 200)).integerValue())
+
+        assertEquals(15625, RuntimeValue(DataType.WORD, 5).pow(RuntimeValue(DataType.WORD, 6)).integerValue())
+        assertEquals(-6487, RuntimeValue(DataType.WORD, 9).pow(RuntimeValue(DataType.WORD, 5)).integerValue())
+
+        assertEquals(18000, RuntimeValue(DataType.WORD, 9000).shl().integerValue())
+        assertEquals(-25536, RuntimeValue(DataType.WORD, 20000).shl().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.WORD, -1).shl().integerValue())
+    }
+}

compiler/test/UnitTests.kt

@@ -5,10 +5,17 @@ import org.hamcrest.Matchers.closeTo
 import org.hamcrest.Matchers.equalTo
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.*
+import prog8.ast.base.DataType
+import prog8.ast.base.Position
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.ReferenceLiteralValue
 import prog8.compiler.*
-import prog8.compiler.intermediate.Value
-import prog8.compiler.target.c64.*
+import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
+import prog8.compiler.target.c64.MachineDefinition.Mflpt5
+import prog8.compiler.target.c64.Petscii
+import prog8.vm.RuntimeValue
 import java.io.CharConversionException
 import kotlin.test.*
 
@@ -138,8 +145,12 @@ class TestZeropage {
         assertFailsWith<CompilerException> {
             zp.allocate("", DataType.FLOAT, null)
         }
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
-        zp2.allocate("", DataType.FLOAT, null)
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true))
+        assertFailsWith<CompilerException> {
+            zp2.allocate("", DataType.FLOAT, null)
+        }
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
+        zp3.allocate("", DataType.FLOAT, null)
     }
 
     @Test
@@ -158,14 +169,16 @@ class TestZeropage {
         }
     }
 
+    // TODO test dontuse option
+
     @Test
     fun testFreeSpaces() {
         val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
-        assertEquals(20, zp1.available())
+        assertEquals(16, zp1.available())
         val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
-        assertEquals(95, zp2.available())
+        assertEquals(91, zp2.available())
         val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false))
-        assertEquals(129, zp3.available())
+        assertEquals(125, zp3.available())
         val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertEquals(238, zp4.available())
     }
@@ -195,11 +208,10 @@ class TestZeropage {
     @Test
     fun testBasicsafeAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
-        assertEquals(20, zp.available())
+        assertEquals(16, zp.available())
 
-        zp.allocate("", DataType.FLOAT, null)
         assertFailsWith<ZeropageDepletedError> {
-            // in regular zp there aren't 5 sequential bytes free after we take the first sequence
+            // in regular zp there aren't 5 sequential bytes free
             zp.allocate("", DataType.FLOAT, null)
         }
 
@@ -249,16 +261,16 @@ class TestZeropage {
     @Test
     fun testEfficientAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true))
-        assertEquals(20, zp.available())
-        assertEquals(0x04, zp.allocate("", DataType.FLOAT, null))
-        assertEquals(0x09, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0x0d, zp.allocate("", DataType.UWORD, null))
+        assertEquals(16, zp.available())
+        assertEquals(0x04, zp.allocate("", DataType.WORD, null))
+        assertEquals(0x06, zp.allocate("", DataType.UBYTE, null))
+        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0x94, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xa7, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xa9, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xb5, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xf7, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null))
+        assertEquals(0x0e, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0, zp.available())
     }
@@ -268,6 +280,14 @@ class TestZeropage {
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestPetscii {
 
+    @Test
+    fun testZero() {
+        assertThat(Petscii.encodePetscii("\u0000", true), equalTo(listOf<Short>(0)))
+        assertThat(Petscii.encodePetscii("\u0000", false), equalTo(listOf<Short>(0)))
+        assertThat(Petscii.decodePetscii(listOf(0), true), equalTo("\u0000"))
+        assertThat(Petscii.decodePetscii(listOf(0), false), equalTo("\u0000"))
+    }
+
     @Test
     fun testLowercase() {
         assertThat(Petscii.encodePetscii("hello WORLD 123 @!£", true), equalTo(
@@ -326,8 +346,8 @@ class TestPetscii {
 
     @Test
     fun testLiteralValueComparisons() {
-        val ten = LiteralValue(DataType.UWORD, wordvalue=10, position=Position("", 0 ,0 ,0))
-        val nine = LiteralValue(DataType.UBYTE, bytevalue=9, position=Position("", 0 ,0 ,0))
+        val ten = NumericLiteralValue(DataType.UWORD, 10, Position("", 0, 0, 0))
+        val nine = NumericLiteralValue(DataType.UBYTE, 9, Position("", 0, 0, 0))
         assertEquals(ten, ten)
         assertNotEquals(ten, nine)
         assertFalse(ten != ten)
@@ -343,23 +363,17 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = LiteralValue(DataType.STR, strvalue = "abc", position=Position("", 0 ,0 ,0))
-        val abd = LiteralValue(DataType.STR, strvalue = "abd", position=Position("", 0 ,0 ,0))
+        val abc = ReferenceLiteralValue(DataType.STR, str = "abc", position = Position("", 0, 0, 0))
+        val abd = ReferenceLiteralValue(DataType.STR, str = "abd", position = Position("", 0, 0, 0))
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)
-        assertTrue(abc < abd)
-        assertTrue(abc <= abd)
-        assertFalse(abd <= abc)
-        assertTrue(abd >= abc)
-        assertTrue(abd > abc)
-        assertFalse(abc > abd)
     }
 
     @Test
     fun testStackvmValueComparisons() {
-        val ten = Value(DataType.FLOAT, 10)
-        val nine = Value(DataType.UWORD, 9)
+        val ten = RuntimeValue(DataType.FLOAT, 10)
+        val nine = RuntimeValue(DataType.UWORD, 9)
         assertEquals(ten, ten)
         assertNotEquals(ten, nine)
         assertFalse(ten != ten)

compiler/test/ValueOperationsTests.kt

@@ -1,299 +0,0 @@
-package prog8tests
-
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.TestInstance
-import prog8.ast.DataType
-import prog8.ast.LiteralValue
-import prog8.ast.Position
-import prog8.compiler.intermediate.Value
-import prog8.compiler.intermediate.ValueException
-import kotlin.test.*
-
-
-private fun sameValueAndType(v1: Value, v2: Value): Boolean {
-    return v1.type==v2.type && v1==v2
-}
-
-private fun sameValueAndType(lv1: LiteralValue, lv2: LiteralValue): Boolean {
-    return lv1.type==lv2.type && lv1==lv2
-}
-
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class TestStackVmValue {
-
-    @Test
-    fun testIdentity() {
-        val v = Value(DataType.UWORD, 12345)
-        assertEquals(v, v)
-        assertFalse(v != v)
-        assertTrue(v<=v)
-        assertTrue(v>=v)
-        assertFalse(v<v)
-        assertFalse(v>v)
-
-        assertTrue(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.UBYTE, 100)))
-    }
-
-    @Test
-    fun testEqualsAndNotEquals() {
-        assertEquals(Value(DataType.UBYTE, 100), Value(DataType.UBYTE, 100))
-        assertEquals(Value(DataType.UBYTE, 100), Value(DataType.UWORD, 100))
-        assertEquals(Value(DataType.UBYTE, 100), Value(DataType.FLOAT, 100))
-        assertEquals(Value(DataType.UWORD, 254), Value(DataType.UBYTE, 254))
-        assertEquals(Value(DataType.UWORD, 12345), Value(DataType.UWORD, 12345))
-        assertEquals(Value(DataType.UWORD, 12345), Value(DataType.FLOAT, 12345))
-        assertEquals(Value(DataType.FLOAT, 100.0), Value(DataType.UBYTE, 100))
-        assertEquals(Value(DataType.FLOAT, 22239.0), Value(DataType.UWORD, 22239))
-        assertEquals(Value(DataType.FLOAT, 9.99), Value(DataType.FLOAT, 9.99))
-
-        assertTrue(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.UBYTE, 100)))
-        assertFalse(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.UWORD, 100)))
-        assertFalse(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.FLOAT, 100)))
-        assertFalse(sameValueAndType(Value(DataType.UWORD, 254), Value(DataType.UBYTE, 254)))
-        assertTrue(sameValueAndType(Value(DataType.UWORD, 12345), Value(DataType.UWORD, 12345)))
-        assertFalse(sameValueAndType(Value(DataType.UWORD, 12345), Value(DataType.FLOAT, 12345)))
-        assertFalse(sameValueAndType(Value(DataType.FLOAT, 100.0), Value(DataType.UBYTE, 100)))
-        assertFalse(sameValueAndType(Value(DataType.FLOAT, 22239.0), Value(DataType.UWORD, 22239)))
-        assertTrue(sameValueAndType(Value(DataType.FLOAT, 9.99), Value(DataType.FLOAT, 9.99)))
-
-        assertNotEquals(Value(DataType.UBYTE, 100), Value(DataType.UBYTE, 101))
-        assertNotEquals(Value(DataType.UBYTE, 100), Value(DataType.UWORD, 101))
-        assertNotEquals(Value(DataType.UBYTE, 100), Value(DataType.FLOAT, 101))
-        assertNotEquals(Value(DataType.UWORD, 245), Value(DataType.UBYTE, 246))
-        assertNotEquals(Value(DataType.UWORD, 12345), Value(DataType.UWORD, 12346))
-        assertNotEquals(Value(DataType.UWORD, 12345), Value(DataType.FLOAT, 12346))
-        assertNotEquals(Value(DataType.FLOAT, 9.99), Value(DataType.UBYTE, 9))
-        assertNotEquals(Value(DataType.FLOAT, 9.99), Value(DataType.UWORD, 9))
-        assertNotEquals(Value(DataType.FLOAT, 9.99), Value(DataType.FLOAT, 9.0))
-
-        assertFalse(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.UBYTE, 101)))
-        assertFalse(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.UWORD, 101)))
-        assertFalse(sameValueAndType(Value(DataType.UBYTE, 100), Value(DataType.FLOAT, 101)))
-        assertFalse(sameValueAndType(Value(DataType.UWORD, 245), Value(DataType.UBYTE, 246)))
-        assertFalse(sameValueAndType(Value(DataType.UWORD, 12345), Value(DataType.UWORD, 12346)))
-        assertFalse(sameValueAndType(Value(DataType.UWORD, 12345), Value(DataType.FLOAT, 12346)))
-        assertFalse(sameValueAndType(Value(DataType.FLOAT, 9.99), Value(DataType.UBYTE, 9)))
-        assertFalse(sameValueAndType(Value(DataType.FLOAT, 9.99), Value(DataType.UWORD, 9)))
-        assertFalse(sameValueAndType(Value(DataType.FLOAT, 9.99), Value(DataType.FLOAT, 9.0)))
-    }
-
-    @Test
-    fun testEqualsAndNotEqualsHeapTypes()
-    {
-        assertTrue(sameValueAndType(Value(DataType.STR, 999), Value(DataType.STR, 999)))
-        assertFalse(sameValueAndType(Value(DataType.STR, 999), Value(DataType.STR, 222)))
-
-        assertTrue(sameValueAndType(Value(DataType.ARRAY_UB, 99), Value(DataType.ARRAY_UB, 99)))
-        assertFalse(sameValueAndType(Value(DataType.ARRAY_UB, 99), Value(DataType.ARRAY_UB, 22)))
-
-        assertTrue(sameValueAndType(Value(DataType.ARRAY_UW, 999), Value(DataType.ARRAY_UW, 999)))
-        assertFalse(sameValueAndType(Value(DataType.ARRAY_UW, 999), Value(DataType.ARRAY_UW, 222)))
-
-        assertTrue(sameValueAndType(Value(DataType.ARRAY_F, 999), Value(DataType.ARRAY_F, 999)))
-        assertFalse(sameValueAndType(Value(DataType.ARRAY_F, 999), Value(DataType.ARRAY_UW, 999)))
-        assertFalse(sameValueAndType(Value(DataType.ARRAY_F, 999), Value(DataType.ARRAY_F, 222)))
-    }
-
-    @Test
-    fun testGreaterThan(){
-        assertTrue(Value(DataType.UBYTE, 100) > Value(DataType.UBYTE, 99))
-        assertTrue(Value(DataType.UWORD, 254) > Value(DataType.UWORD, 253))
-        assertTrue(Value(DataType.FLOAT, 100.0) > Value(DataType.FLOAT, 99.9))
-
-        assertTrue(Value(DataType.UBYTE, 100) >= Value(DataType.UBYTE, 100))
-        assertTrue(Value(DataType.UWORD, 254) >= Value(DataType.UWORD, 254))
-        assertTrue(Value(DataType.FLOAT, 100.0) >= Value(DataType.FLOAT, 100.0))
-
-        assertFalse(Value(DataType.UBYTE, 100) > Value(DataType.UBYTE, 100))
-        assertFalse(Value(DataType.UWORD, 254) > Value(DataType.UWORD, 254))
-        assertFalse(Value(DataType.FLOAT, 100.0) > Value(DataType.FLOAT, 100.0))
-
-        assertFalse(Value(DataType.UBYTE, 100) >= Value(DataType.UBYTE, 101))
-        assertFalse(Value(DataType.UWORD, 254) >= Value(DataType.UWORD, 255))
-        assertFalse(Value(DataType.FLOAT, 100.0) >= Value(DataType.FLOAT, 100.1))
-    }
-
-    @Test
-    fun testLessThan() {
-        assertTrue(Value(DataType.UBYTE, 100) < Value(DataType.UBYTE, 101))
-        assertTrue(Value(DataType.UWORD, 254) < Value(DataType.UWORD, 255))
-        assertTrue(Value(DataType.FLOAT, 100.0) < Value(DataType.FLOAT, 100.1))
-
-        assertTrue(Value(DataType.UBYTE, 100) <= Value(DataType.UBYTE, 100))
-        assertTrue(Value(DataType.UWORD, 254) <= Value(DataType.UWORD, 254))
-        assertTrue(Value(DataType.FLOAT, 100.0) <= Value(DataType.FLOAT, 100.0))
-
-        assertFalse(Value(DataType.UBYTE, 100) < Value(DataType.UBYTE, 100))
-        assertFalse(Value(DataType.UWORD, 254) < Value(DataType.UWORD, 254))
-        assertFalse(Value(DataType.FLOAT, 100.0) < Value(DataType.FLOAT, 100.0))
-
-        assertFalse(Value(DataType.UBYTE, 100) <= Value(DataType.UBYTE, 99))
-        assertFalse(Value(DataType.UWORD, 254) <= Value(DataType.UWORD, 253))
-        assertFalse(Value(DataType.FLOAT, 100.0) <= Value(DataType.FLOAT, 99.9))
-    }
-
-    @Test
-    fun testNoDtConversion() {
-        assertFailsWith<ValueException> {
-            Value(DataType.UWORD, 100).add(Value(DataType.UBYTE, 120))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UBYTE, 100).add(Value(DataType.UWORD, 120))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.FLOAT, 100.22).add(Value(DataType.UWORD, 120))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UWORD, 1002).add(Value(DataType.FLOAT, 120.22))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.FLOAT, 100.22).add(Value(DataType.UBYTE, 120))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UBYTE, 12).add(Value(DataType.FLOAT, 120.22))
-        }
-    }
-
-    @Test
-    fun testNoAutoFloatConversion() {
-        assertFailsWith<ValueException> {
-            Value(DataType.UBYTE, 233).add(Value(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UWORD, 233).add(Value(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UBYTE, 233).mul(Value(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UWORD, 233).mul(Value(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UBYTE, 233).div(Value(DataType.FLOAT, 1.234))
-        }
-        assertFailsWith<ValueException> {
-            Value(DataType.UWORD, 233).div(Value(DataType.FLOAT, 1.234))
-        }
-        val result = Value(DataType.FLOAT, 233.333).add(Value(DataType.FLOAT, 1.234))
-    }
-}
-
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class TestParserLiteralValue {
-
-    private val dummyPos = Position("test", 0,0,0)
-
-    @Test
-    fun testIdentity() {
-        val v = LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos)
-        assertEquals(v, v)
-        assertFalse(v != v)
-        assertTrue(v <= v)
-        assertTrue(v >= v)
-        assertFalse(v < v)
-        assertFalse(v > v)
-
-        assertTrue(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos)))
-    }
-
-    @Test
-    fun testEqualsAndNotEquals() {
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos), LiteralValue(DataType.UBYTE, 254, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12345.0, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=22239.0, position=dummyPos), LiteralValue(DataType.UWORD,wordvalue=22239, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos))
-
-        assertTrue(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos), LiteralValue(DataType.UBYTE, 254, position=dummyPos)))
-        assertTrue(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12345.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=22239.0, position=dummyPos), LiteralValue(DataType.UWORD,wordvalue=22239, position=dummyPos)))
-        assertTrue(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos)))
-
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=101, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=101.0, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=245, position=dummyPos), LiteralValue(DataType.UBYTE, 246, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12346, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12346.0, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UBYTE, 9, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=9, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.0, position=dummyPos))
-
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 101, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=101, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=101.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=245, position=dummyPos), LiteralValue(DataType.UBYTE, 246, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12346, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12346.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UBYTE, 9, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=9, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.0, position=dummyPos)))
-
-        assertTrue(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position=dummyPos), LiteralValue(DataType.STR, strvalue="hello", position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position=dummyPos), LiteralValue(DataType.STR, strvalue="bye", position=dummyPos)))
-
-        val lvOne = LiteralValue(DataType.UBYTE, 1, position=dummyPos)
-        val lvTwo = LiteralValue(DataType.UBYTE, 2, position=dummyPos)
-        val lvThree = LiteralValue(DataType.UBYTE, 3, position=dummyPos)
-        val lvOneR = LiteralValue(DataType.UBYTE, 1, position=dummyPos)
-        val lvTwoR = LiteralValue(DataType.UBYTE, 2, position=dummyPos)
-        val lvThreeR = LiteralValue(DataType.UBYTE, 3, position=dummyPos)
-        val lvFour= LiteralValue(DataType.UBYTE, 4, position=dummyPos)
-        val lv1 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOne, lvTwo, lvThree), position=dummyPos)
-        val lv2 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvThreeR), position=dummyPos)
-        val lv3 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvFour), position=dummyPos)
-        assertEquals(lv1, lv2)
-        assertNotEquals(lv1, lv3)
-    }
-
-    @Test
-    fun testGreaterThan(){
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) > LiteralValue(DataType.UBYTE, 99, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) > LiteralValue(DataType.UWORD, wordvalue=253, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) > LiteralValue(DataType.FLOAT, floatvalue=99.9, position=dummyPos))
-
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) >= LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) >= LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) > LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) > LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) > LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) >= LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) >= LiteralValue(DataType.UWORD,wordvalue= 255, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue=100.1, position=dummyPos))
-    }
-
-    @Test
-    fun testLessThan() {
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) < LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) < LiteralValue(DataType.UWORD, wordvalue=255, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) < LiteralValue(DataType.FLOAT, floatvalue=100.1, position=dummyPos))
-
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) <= LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) <= LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) < LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) < LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) < LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) <= LiteralValue(DataType.UBYTE, 99, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos) <= LiteralValue(DataType.UWORD,wordvalue= 253, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT,floatvalue= 100.0, position=dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue=99.9, position=dummyPos))
-    }
-
-}
-

docs/source/building.rst

@@ -2,29 +2,50 @@
 Writing and building a program
 ==============================
 
+.. _building_compiler:
+
 First, getting a working compiler
 ---------------------------------
 
-Before you can compile Prog8 programs, you'll have to build the compiler itself.
+Before you can compile Prog8 programs, you'll have to download or build the compiler itself.
 First make sure you have installed the :ref:`requirements`.
-Then you can choose a few ways to create the compiler:
+Then you can choose a few ways to get a compiler:
 
-**Using the shell script:**
+**Download a precompiled version from github:**
 
-#. run the "build_the_compiler.sh" shell script
-#. it will create a "prog8compiler.jar" file which contains everything.
-#. run the compiler with "java -jar prog8compiler.jar" to see how you can use it.
+#. download a recent "fat-jar" (called something like "prog8compiler-all.jar") from `the releases on Github <https://github.com/irmen/prog8/releases>`_
+#. run the compiler with "java -jar prog8compiler-all.jar" to see how you can use it.
 
-**using the Gradle build system:**
+**using the Gradle build system to make it yourself:**
 
-#. run the command "./gradlew installDist"
-#. it will create the commands and required libraries in the "./compiler/build/install/p8compile/" directory
-#. run the compiler with the "./compiler/build/install/p8compile/bin/p8compile" command to see how you can use it.
+The Gradle build system is used to build the compiler.
+The most interesting gradle commands to run are probably:
 
-**download a precompiled version from github:**
+    ``./gradlew check``
+        Builds the compiler code and runs all available checks and unit-tests.
+    ``./gradlew installDist``
+        Builds the compiler and installs it with scripts to run it, in the directory
+        ``./compiler/build/install/p8compile``
+    ``./gradlew installShadowDist``
+        Creates a 'fat-jar' that contains the compiler and all dependencies, in a single
+        executable .jar file, and includes few start scripts to run it.
+        The output can be found in ``.compiler/build/install/compiler-shadow/``
+    ``./gradlew shadowDistZip``
+        Creates a zipfile with the above in it, for easy distribution.
+        This file can be found in ``./compiler/build/distributions/``
+
+For normal use, the ``installDist`` target should suffice and ater succesful completion
+of that build task, you can start the compiler with:
+
+    ``./compiler/build/install/p8compile/bin/p8compile <options> <sourcefile>``
+
+(You should probably make an alias...)
+
+.. note::
+    Development and testing is done on Linux, but the compiler should run on most
+    operating systems. If you do have trouble building or running
+    the compiler on another operating system, please let me know!
 
-#. download a recent "prog8compiler.jar" from `the releases on Github <https://github.com/irmen/prog8/releases>`_
-#. run the compiler with "java -jar prog8compiler.jar" to see how you can use it.
 
 
 What is a Prog8 "Program" anyway?
@@ -53,14 +74,10 @@ The compiler will link everything together into one output program at the end.
 If you start the compiler without arguments, it will print a short usage text.
 For normal use the compiler is invoked with the command:
 
-    ``$ java -jar prog8compiler.jar sourcefile.p8``   if you're using the packaged release version, or
+    ``$ java -jar prog8compiler.jar sourcefile.p8``
 
-    ``$ ./p8compile.sh sourcefile.p8``   if you're running an unpackaged development version.
-
-If you tell it to save the intermediate code for the prog8 virtual machine, you can
-actually run this code with the command:
-
-    ``$ ./p8vm.sh sourcefile.vm.txt``
+    Other options are also available, see the introduction page about how
+    to build and run the compiler.
 
 
 By default, assembly code is generated and written to ``sourcefile.asm``.
@@ -70,6 +87,13 @@ If you use the option to let the compiler auto-start a C-64 emulator, it will do
 a successful compilation. This will load your program and the symbol and breakpoint lists
 (for the machine code monitor) into the emulator.
 
+Continuous compilation mode
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Almost instant compilation times (<0.1 second) can be achieved when using the continuous compilation mode.
+Start the compiler with the ``-watch`` argument to enable this.
+It will compile your program and then instead of exiting, it waits for any changes in the module source files.
+As soon as a change happens, the program gets compiled again.
+
 
 Module source code files
 ------------------------
@@ -84,6 +108,13 @@ They are embedded into the packaged release version of the compiler so you don't
 where they are, but their names are still reserved.
 
 
+User defined library files
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+You can create library files yourself too that can be shared among programs.
+You can tell the compiler where it should look for these files, by setting the java command line property ``prog8.libdir``
+or by setting the ``PROG8_LIBDIR`` environment variable to the correct directory.
+
+
 .. _debugging:
 
 Debugging (with Vice)
@@ -130,3 +161,24 @@ or::
 
     $ ./p8compile.sh -emu examples/rasterbars.p8
 
+
+
+Virtual Machine
+---------------
+
+You may have noticed the ``-avm`` and ``-vm`` command line options for the compiler:
+
+-avm
+    Launches the "AST virtual machine" that directly executes the parsed program.
+    No compilation steps will be performed.
+    Allows for very fast testing and debugging before actually compiling programs
+    to machine code.
+    It simulates a bare minimum of features from the target platform, so most stuff
+    that calls ROM routines or writes into hardware registers won't work. But basic
+    system routines are emulated.
+
+-vm   <vm bytecode file>
+    Launches the "intermediate code VM"
+    it interprets the intermediate code that the compiler can write when using the ``-writevm``
+    option. This is the code that will be fed to the assembly code generator,
+    so you'll skip that last step.

docs/source/index.rst

@@ -37,15 +37,15 @@ This software is licensed under the GNU GPL 3.0, see https://www.gnu.org/license
     :alt: Fully playable tetris clone
 
 
-Code example
-------------
+Code examples
+-------------
 
 This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
     %import c64utils
     %zeropage basicsafe
 
-    ~ main {
+    main {
 
         ubyte[256] sieve
         ubyte candidate_prime = 2
@@ -89,13 +89,47 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
     }
 
 
-when compiled an ran on a C-64 you'll get:
+when compiled an ran on a C-64 you get this:
 
 .. image:: _static/primes_example.png
     :align: center
     :alt: result when run on C-64
 
 
+The following programs shows a use of the high level ``struct`` type::
+
+    %import c64utils
+    %zeropage basicsafe
+
+    main {
+
+        struct Color {
+            ubyte red
+            ubyte green
+            ubyte blue
+        }
+
+        sub start() {
+
+            Color purple = {255, 0, 255}
+            Color other
+            other = purple
+            other.red /= 2
+            other.green = 10 + other.green / 2
+            other.blue = 99
+
+            c64scr.print_ub(other.red)
+            c64.CHROUT(',')
+            c64scr.print_ub(other.green)
+            c64.CHROUT(',')
+            c64scr.print_ub(other.blue)
+            c64.CHROUT('\n')
+        }
+    }
+
+when compiled and ran, it prints  ``127,10,99`` on the screen.
+
+
 Design principles and features
 ------------------------------
 
@@ -106,7 +140,8 @@ Design principles and features
 - 'One statement per line' code style, resulting in clear readable programs.
 - Modular programming and scoping via modules, code blocks, and subroutines.
 - Provide high level programming constructs but stay close to the metal;
-  still able to directly use memory addresses, CPU registers and ROM subroutines
+  still able to directly use memory addresses, CPU registers and ROM subroutines,
+  and inline assembly to have full control when every cycle or byte matters
 - Arbitrary number of subroutine parameters (constrained only by available memory)
 - Complex nested expressions are possible
 - Values are typed. Types supported include signed and unsigned bytes and words, arrays, strings and floats.
@@ -136,34 +171,21 @@ For other platforms it is very easy to compile it yourself (make ; make install)
 
 A **Java runtime (jre or jdk), version 8 or newer**  is required to run the packaged compiler.
 If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK instead
-and for Windows it's possible to get that as well: for instance,
-`Azul's Zulu <https://www.azul.com/downloads/zulu/>`_ is a certified OpenJDK
-implementation available for various platforms.
+and for Windows it's possible to get that as well. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ for
+downloads.
 
 Finally: a **C-64 emulator** (or a real C-64 ofcourse) to run the programs on. The compiler assumes the presence
 of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
 
-.. hint::
-    The compiler is almost completely written in Kotlin, but the packaged release version
-    only requires a Java runtime. All other needed libraries and files are embedded in the
-    packaged jar file.
+.. important::
+    **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)
 
-.. note::
-    Building the compiler itself:
-
-    (re)building the compiler itself requires a Kotlin SDK version 1.3.
+    (re)building the compiler itself requires a recent Kotlin SDK.
     The compiler is developed using the `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_
     IDE from Jetbrains, with the Kotlin plugin (free community edition of this IDE is available).
     But a bare Kotlin SDK installation should work just as well.
-    A shell script (``build_the_compiler.sh``) is provided to build and package the compiler from the command line.
-    You can also use the Gradle build system to build the compiler (it will take care of
-    downloading all required libraries for you) by typing ``gradle installDist`` for instance.
-    The output of this gradle build will appear in the "./compiler/build/install/p8compile/" directory.
 
-.. note::
-    Development and testing is done on Linux, but the compiler should run on most
-    operating systems. If you do have trouble building or running
-    the compiler on another operating system, please let me know!
+    Instructions on how to obtain a working compiler are in :ref:`building_compiler`.
 
 
 .. toctree::

docs/source/programming.rst

@@ -54,7 +54,7 @@ Code
 
 	- value assignment
 	- looping  (for, while, repeat, unconditional jumps)
-	- conditional execution (if - then - else, and conditional jumps)
+	- conditional execution (if - then - else, when, and conditional jumps)
 	- subroutine calls
 	- label definition
 
@@ -93,7 +93,7 @@ Blocks, Scopes, and accessing Symbols
 **Blocks** are the top level separate pieces of code and data of your program. They are combined
 into a single output program.  No code or data can occur outside a block. Here's an example::
 
-	~ main $c000 {
+	main $c000 {
 		; this is code inside the block...
 	}
 
@@ -127,12 +127,20 @@ The address must be >= ``$0200`` (because ``$00``--``$ff`` is the ZP and ``$100`
 to them by their 'short' name directly.  If the symbol is not found in the same scope,
 the enclosing scope is searched for it, and so on, until the symbol is found.
 
-Scopes are created using several statements:
+Scopes are created using either of these two statements:
 
 - blocks  (top-level named scope)
-- subroutines   (nested named scopes)
-- for, while, repeat loops   (anonymous scope)
-- if statements and branching conditionals    (anonymous scope)
+- subroutines   (nested named scope)
+
+.. note::
+    In contrast to many other programming languages, a new scope is *not* created inside
+    for, while and repeat statements, nor for the if statement and branching conditionals.
+    This is a bit restrictive because you have to think harder about what variables you
+    want to use inside a subroutine. But it is done precisely for this reason; memory in the
+    target system is very limited and it would be a waste to allocate a lot of variables.
+
+    Right now the prog8 compiler is not advanced enough to be able to 'share' or 'overlap'
+    variables intelligently by itself. So for now, it's something the programmer has to think about.
 
 
 Program Start and Entry Point
@@ -151,7 +159,7 @@ taking no parameters and having no return value.
 
 As any subroutine, it has to end with a ``return`` statement (or a ``goto`` call)::
 
-	~ main {
+	main {
 	    sub start ()  {
 	        ; program entrypoint code here
 	        return
@@ -237,6 +245,7 @@ Arrays
 ^^^^^^
 Array types are also supported. They can be made of bytes, words or floats::
 
+    byte[10]  array                   ; array of 10 bytes, initially set to 0
     byte[]  array = [1, 2, 3, 4]      ; initialize the array, size taken from value
     byte[99] array = 255              ; initialize array with 99 times 255 [255, 255, 255, 255, ...]
     byte[] array = 100 to 199         ; initialize array with [100, 101, ..., 198, 199]
@@ -266,6 +275,13 @@ Strings in your source code files will be encoded (translated from ASCII/UTF-8)
 PETSCII is the default choice. If you need screencodes (also called 'poke' codes) instead,
 you have to use the ``str_s`` variants of the string type identifier.
 
+You can concatenate two string literals using '+' (not very useful though) or repeat
+a string literal a given number of times using '*'::
+
+    str string1 = "first part" + "second part"
+    str string2 = "hello!" * 10
+
+
 .. caution::
     It's probably best that you don't change strings after they're created.
     This is because if your program exits and is restarted (without loading it again),
@@ -273,6 +289,39 @@ you have to use the ``str_s`` variants of the string type identifier.
     The same is true for arrays by the way.
 
 
+Structs
+^^^^^^^
+
+A struct is a group of one or more other variables.
+This allows you to reuse the definition and manipulate it as a whole.
+Individual variables in the struct are accessed as you would expect, just
+use a scoped name to refer to them: ``structvariable.membername``.
+
+Structs are a bit limited in Prog8: you can only use numerical variables
+as member of a struct, so strings and arrays and other structs can not be part of a struct.
+Also, it is not possible to use a struct itself inside an array.
+Structs are mainly syntactic sugar for repeated groups of vardecls
+and assignments that belong together. However,
+*they are layed out in sequence in memory as the members are defined*
+which may be usefulif you want to pass pointers around.
+
+To create a variable of a struct type you need to define the struct itself,
+and then create a variable with it::
+
+    struct Color {
+        ubyte red
+        ubyte green
+        ubyte blue
+    }
+
+    Color rgb = {255,122,0}     ; note the curly braces here instead of brackets
+    Color another               ; the init value is optional, like arrays
+
+    another = rgb           ; assign all of the values of rgb to another
+    another.blue = 255      ; set a single member
+
+
+
 Special types: const and memory-mapped
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -321,10 +370,17 @@ Initial values across multiple runs of the program
 When declaring values with an initial value, this value will be set into the variable each time
 the program reaches the declaration again. This can be in loops, multiple subroutine calls,
 or even multiple invocations of the entire program.  If you omit an initial value, it will
-be set to zero only for the first run of the program. A second run will utilize the last value
+be set to zero *but only for the first run of the program*. A second run will utilize the last value
 where it left off (but your code will be a bit smaller because no initialization instructions
 are generated)
 
+This only works for simple types, *and not for string variables and arrays*.
+It is assumed these are left unchanged by the program; they are not re-initialized on
+a second run.
+If you do modify them in-place, you should take care yourself that they work as
+expected when the program is restarted.
+(This is an optimization choice to avoid having to store two copies of every string and array)
+
 .. caution::
    variables that get allocated in zero-page will *not* have a zero starting value when you omit
    the variable's initialization. They'll be whatever the last value in that zero page
@@ -334,12 +390,6 @@ are generated)
     this behavior may change in a future version so that subsequent runs always
     use the same initial values
 
-This only works for simple types, *and not for string variables and arrays*.
-It is assumed these are left unchanged by the program.
-If you do modify them in-place, you should take care yourself that they work as
-expected when the program is restarted.
-(This is an optimization choice to avoid having to store two copies of every string and array)
-
 
 Loops
 -----
@@ -358,12 +408,17 @@ You can also create loops by using the ``goto`` statement, but this should usual
     The value of the loop variable or register after executing the loop *is undefined*. Don't use it immediately
     after the loop without first assigning a new value to it!
     (this is an optimization issue to avoid having to deal with mostly useless post-loop logic to adjust the loop variable's value)
-    Loop variables that are declared inline are scoped in the loop body so they're not accessible at all after the loop finishes.
+    Loop variables that are declared inline are not different to them being
+    defined in a separate var declaration in the subroutine, it's just a readability convenience.
+    (this may change in the future if the compiler gets more advanced with additional sub-scopes)
 
 
 Conditional Execution
 ---------------------
 
+if statements
+^^^^^^^^^^^^^
+
 Conditional execution means that the flow of execution changes based on certiain conditions,
 rather than having fixed gotos or subroutine calls::
 
@@ -413,6 +468,27 @@ So ``if_cc goto target`` will directly translate into the single CPU instruction
     Maybe in the future this will be a separate nested scope, but for now, that is
     only possible when defining a subroutine.
 
+when statement ('jump table')
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Instead of writing a bunch of sequential if-elseif statements, it is more readable to
+use a ``when`` statement. (It will also result in greatly improved assembly code generation)
+Use a ``when`` statement if you have a set of fixed choices that each should result in a certain
+action. It is possible to combine several choices to result in the same action::
+
+    when value {
+        4 -> c64scr.print("four")
+        5 -> c64scr.print("five")
+        10,20,30 -> {
+            c64scr.print("ten or twenty or thirty")
+        }
+        else -> c64scr.print("don't know")
+    }
+
+The when-*value* can be any expression but the choice values have to evaluate to
+compile-time constant integers (bytes or words). They also have to be the same
+datatype as the when-value, otherwise no efficient comparison can be done.
+
 
 Assignments
 -----------

docs/source/syntaxreference.rst

@@ -74,6 +74,7 @@ Directives
       As with ``kernalsafe``, it is not possible to cleanly exit the program, other than to reset the machine.
       This option makes programs smaller and faster because even more variables can
       be stored in the ZP (which allows for more efficient assembly code).
+    - style ``dontuse`` -- don't use *any* location in the zeropage.
 
     Also read :ref:`zeropage`.
 
@@ -173,7 +174,7 @@ Code blocks
 A named block of actual program code. Itefines a *scope* (also known as 'namespace') and
 can contain Prog8 *code*, *directives*, *variable declarations* and *subroutines*::
 
-    ~ <blockname> [<address>] {
+    <blockname> [<address>] {
         <directives>
         <variables>
         <statements>
@@ -185,7 +186,7 @@ The <address> is optional. If specified it must be a valid memory address such a
 It's used to tell the compiler to put the block at a certain position in memory.
 Also read :ref:`blocks`.  Here is an example of a code block, to be loaded at ``$c000``::
 
-	~ main $c000 {
+	main $c000 {
 		; this is code inside the block...
 	}
 
@@ -215,7 +216,7 @@ Variable declarations
 ^^^^^^^^^^^^^^^^^^^^^
 
 Variables should be declared with their exact type and size so the compiler can allocate storage
-for them. You must give them an initial value as well. That value can be a simple literal value,
+for them. You can give them an initial value as well. That value can be a simple literal value,
 or an expression. You can add a ``@zp`` zeropage-tag, to tell the compiler to prioritize it
 when selecting variables to be put into zeropage.
 The syntax is::
@@ -231,10 +232,11 @@ Various examples::
     str         name    = "my name is Irmen"
     uword       address = &counter
     byte[]      values  = [11, 22, 33, 44, 55]
+    byte[5]     values                  ; array of 5 bytes, initially set to zero
     byte[5]     values  = 255           ; initialize with five 255 bytes
 
     word  @zp   zpword = 9999           ; prioritize this when selecting vars for zeropage storage
-
+    Color       rgb    = {1,255,0}      ; a struct variable with initial values
 
 
 Data types
@@ -358,6 +360,26 @@ Syntax is familiar with brackets:  ``arrayvar[x]`` ::
     string[4]       ; the fifth character (=byte) in the string
 
 
+Struct
+^^^^^^
+
+A *struct* has to be defined to specify what its member variables are.
+There are one or more members::
+
+    struct  <structname> {
+        <vardecl>
+        [ <vardecl> ...]
+    }
+
+You can only use numerical variables as member of a struct, so strings and arrays
+and other structs can not be part of a struct. Vice versa, a struct can not occur in an array.
+
+After defining a struct you can use the name of the struct as a data type to declare variables with.
+
+Struct variables can be assigned a struct literal value (also in their declaration as initial value)::
+
+    Color rgb = {255, 100, 0}          ; curly braces instead of brackets
+
 
 Operators
 ---------
@@ -366,7 +388,7 @@ arithmetic: ``+``  ``-``  ``*``  ``/``  ``**``  ``%``
     ``+``, ``-``, ``*``, ``/`` are the familiar arithmetic operations.
     ``/`` is division (will result in integer division when using on integer operands, and a floating point division when at least one of the operands is a float)
     ``**`` is the power operator: ``3 ** 5`` is equal to 3*3*3*3*3 and is 243. (it only works on floating point variables)
-    ``%`` is the remainder operator: ``25 % 7`` is 4.  Be careful: without a space, %10 will be parsed as the binary number 2
+    ``%`` is the remainder operator: ``25 % 7`` is 4.  Be careful: without a space, %10 will be parsed as the binary number 2.
     Remainder is only supported on integer operands (not floats).
 
 bitwise arithmetic: ``&``  ``|``  ``^``  ``~``  ``<<``  ``>>``
@@ -444,11 +466,12 @@ Normal subroutines can only return zero or one return values.
 However, the special ``asmsub`` routines (implemented in assembly code or referencing
 a routine in kernel ROM) can return more than one return values, for instance a status
 in the carry bit and a number in A, or a 16-bit value in A/Y registers.
-Only for these kind of subroutines it is possible to write a multi value assignment to
-store the resulting values::
-
-        var1, var2, var3 = asmsubroutine()
-
+It is not possible to process the results of a call to these kind of routines
+directly from the language, because only single value assignments are possible.
+You can still call the subroutine and not store the results.
+But if you want to do something with the values it returns, you'll have to write
+a small block of custom inline assembly that does the call and stores the values
+appropriately. Don't forget to save/restore the registers if required.
 
 
 Subroutine definitions
@@ -523,7 +546,8 @@ And this is a loop over the values of the array ``fibonacci_numbers`` where the
     }
 
 
-You can inline the loop variable declaration in the for statement, including optional zp-tag::
+You can inline the loop variable declaration in the for statement, including optional zp-tag. In this case
+the variable is not visible outside of the for loop::
 
     for ubyte @zp fastindex in 10 to 20 {
         ; do something
@@ -608,3 +632,29 @@ where <statements> can be just a single statement for instance just a ``goto``,
 The XX corresponds to one of the eigth branching instructions so the possibilities are:
 ``if_cs``, ``if_cc``, ``if_eq``, ``if_ne``, ``if_pl``, ``if_mi``, ``if_vs`` and ``if_vc``.
 It can also be one of the four aliases that are easier to read: ``if_z``, ``if_nz``, ``if_pos`` and ``if_neg``.
+
+when statement ('jump table')
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The structure of a when statement is like this::
+
+    when <expression> {
+        <value(s)> -> <statement(s)>
+        <value(s)> -> <statement(s)>
+        ...
+        [ else -> <statement(s)> ]
+    }
+
+The when-*value* can be any expression but the choice values have to evaluate to
+compile-time constant integers (bytes or words).
+The else part is optional.
+Choices can result in a single statement or a block of  multiple statements in which
+case you have to use { } to enclose them::
+
+    when value {
+        4 -> c64scr.print("four")
+        5 -> c64scr.print("five")
+        10,20,30 -> {
+            c64scr.print("ten or twenty or thirty")
+        }
+        else -> c64scr.print("don't know")
+    }