doc

removed avg function because of hidden internal overflow issues

.gitignore

@@ -1,4 +1,5 @@
 .idea/workspace.xml
+.idea/discord.xml
 /build/
 /dist/
 /output/

.idea/.gitignore

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

.idea/modules.xml

@@ -2,6 +2,7 @@
 <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" />

.travis.yml

@@ -1,11 +1,11 @@
 language: java
+sudo: false
 # jdk: openjdk8
 # dist: xenial
-# sudo: false
 
 before_install:
   - chmod +x gradlew
 
 script:
-  - ./gradlew test
+  - gradle 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,4 +1,4 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
 import prog8.vm.RuntimeValue
 import prog8.vm.stackvm.Syscall
@@ -15,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)
@@ -24,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,4 +1,4 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
 import prog8.ast.antlr.escape
 import prog8.ast.base.*
@@ -34,7 +34,7 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
     val memory = mutableMapOf<Int, List<RuntimeValue>>()
     private lateinit var currentBlock: ProgramBlock
 
-    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) {
@@ -85,7 +85,7 @@ 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!!.asBoolean
@@ -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)
                 }
@@ -315,12 +315,12 @@ 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-> {
+                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)
@@ -462,7 +462,7 @@ 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)
     }
 

DeprecatedStackVm/src/compiler/intermediate/Opcode.kt

@@ -1,4 +1,4 @@
-package prog8.compiler.intermediate
+package compiler.intermediate
 
 enum class Opcode {
 

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

@@ -1,4 +1,4 @@
-package prog8.compiler.target.c64
+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
@@ -12,6 +12,9 @@ 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.*
@@ -229,7 +232,7 @@ class AsmGen(private val options: CompilationOptions, private val program: Inter
 
     private fun block2asm(blk: IntermediateProgram.ProgramBlock) {
         block = blk
-        out("\n; ---- block: '${block.name}' ----")
+        out("\n\n; ---- block: '${block.name}' ----")
         if(!blk.force_output)
             out("${block.name}\t.proc\n")
         if(block.address!=null) {
@@ -302,7 +305,7 @@ class AsmGen(private val options: CompilationOptions, private val program: Inter
         val (structMembers, normalVars) = block.variables.partition { it.params.memberOfStruct!=null }
         structMembers.forEach { vardecl2asm(it.scopedname, it.value, it.params) }
 
-        // leave outsort the other variables by type
+        // sort the other variables by type
         out(";  other variables sorted by type")
         val sortedVars = normalVars.sortedBy { it.value.type }
         for (variable in sortedVars) {
@@ -533,7 +536,7 @@ class AsmGen(private val options: CompilationOptions, private val program: Inter
         }
 
         // add any matching patterns from the big list
-        for(pattern in patterns) {
+        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)
@@ -560,31 +563,31 @@ class AsmGen(private val options: CompilationOptions, private val program: Inter
             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.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.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.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_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})
+                    """
+                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})
+                    """
+                lda  #<($variable+${index * MachineDefinition.Mflpt5.MemorySize})
+                ldy  #>($variable+${index * MachineDefinition.Mflpt5.MemorySize})
                 jsr  c64flt.dec_var_f
                 """)
 

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

@@ -1,4 +1,4 @@
-package prog8.compiler.target.c64
+package compiler.target.c64.codegen
 
 import prog8.compiler.CompilerException
 import prog8.compiler.intermediate.Instruction
@@ -459,8 +459,8 @@ internal fun simpleInstr2Asm(ins: Instruction, block: IntermediateProgram.Progra
         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_float2uw"
-        Opcode.CAST_F_TO_B -> " jsr  c64flt.stack_float2w"
+        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
@@ -513,27 +513,27 @@ internal fun simpleInstr2Asm(ins: Instruction, block: IntermediateProgram.Progra
         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.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.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.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.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.NOTEQUAL_F -> "  jsr  c64flt.notequal_f"
 
         Opcode.LESS_UB -> "  jsr  prog8_lib.less_ub"
         Opcode.LESS_B -> "  jsr  prog8_lib.less_b"

README.md

@@ -14,39 +14,40 @@ 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 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)
-- automatic variable allocations, automatic string variables and string sharing
-- constant folding in expressions (compile-time evaluation)
+- various data types other than just bytes (16-bit words, floats, strings)
+- automatic variable allocations, automatic string and array variables and string sharing
+- subroutines with a input- and output parameter signature
+- constant folding in expressions
 - conditional branches
-- when statement to provide a 'jump table' alternative to if/elseif chains
+- 'when' statement to provide a concise 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  (uses the C64 Basic ROM routines for this)
+- floating point operations  (requires 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...) 
+- 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
+- many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
 
 Rapid edit-compile-run-debug cycle:
 
 - use modern PC to work on 
-- quick compilation times (less than 1 second)
+- quick compilation times (seconds)
 - 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
-- 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
+- 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 
 
 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.
@@ -68,7 +69,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

@@ -22,8 +22,6 @@ repositories {
     jcenter()
 }
 
-sourceCompatibility = 1.8
-
 def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
 
 dependencies {
@@ -49,6 +47,12 @@ compileKotlin {
     }
 }
 
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
 sourceSets {
     main {
         java {
@@ -77,9 +81,6 @@ artifacts {
 }
 
 
-// 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

compiler/compiler.iml

@@ -8,7 +8,7 @@
       <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="jdk" jdkName="openjdk-11" 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" />

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
@@ -52,7 +52,7 @@ asmsub	MOVMF		(uword mflpt @ XY) clobbers(A,Y)	= $bbd4		; store fac1 to memory
 
 ; 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)
@@ -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
@@ -954,6 +954,16 @@ func_sum_f	.proc
 		bne  -
 +		jmp  push_fac1_as_result
 		.pend
+		
+sign_f		.proc
+		jsr  pop_float_fac1
+		jsr  SIGN
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend
+		
+
 }}
 
 }  ; ------ end of block c64flt

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
@@ -202,12 +202,12 @@ asmsub	CINT     () clobbers(A,X,Y)			= $FF81		; (alias: SCINIT) initialize scree
 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	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   (ubyte dir @ Pc, uword address @ XY) -> uword @ XY	= $FF99		; read/set top of memory  pointer
-asmsub	MEMBOT   (ubyte dir @ Pc, uword address @ XY) -> uword @ XY	= $FF9C		; read/set bottom of memory  pointer
+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
@@ -235,7 +235,7 @@ asmsub	GETIN    () clobbers(X,Y) -> ubyte @ A		= $FFE4		; (via 810 ($32A)) get a
 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 dir @ Pc, ubyte col @ Y, ubyte row @ X) -> ubyte @ X, ubyte @ Y	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
+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
@@ -461,7 +461,7 @@ _raster_irq_handler
 
 
 
-~ c64scr {
+c64scr {
 	; ---- this block contains (character) Screen and text I/O related functions ----
 
 
@@ -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 {{
@@ -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,15 +1072,15 @@ 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
 	}}

compiler/res/prog8lib/math.asm

@@ -643,3 +643,40 @@ mul_word_40	.proc
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
+
+sign_b		.proc
+		lda  c64.ESTACK_LO+1,x
+		beq  _sign_zero
+		bmi  _sign_neg
+_sign_pos	lda  #1
+		sta  c64.ESTACK_LO+1,x
+		rts
+_sign_neg	lda  #-1
+_sign_zero	sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+sign_ub		.proc
+		lda  c64.ESTACK_LO+1,x
+		beq  sign_b._sign_zero
+		bne  sign_b._sign_pos
+		.pend
+
+sign_w		.proc
+		lda  c64.ESTACK_HI+1,x
+		bmi  sign_b._sign_neg
+		beq  sign_ub
+		bne  sign_b._sign_pos
+		.pend
+
+sign_uw		.proc
+		lda  c64.ESTACK_HI+1,x
+		beq  _sign_possibly_zero
+_sign_pos	lda  #1
+		sta  c64.ESTACK_LO+1,x
+		rts
+_sign_possibly_zero	lda  c64.ESTACK_LO+1,x
+		bne  _sign_pos
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend

compiler/res/prog8lib/math.p8

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

compiler/res/prog8lib/prog8lib.asm

@@ -36,6 +36,17 @@ init_system	.proc
 		.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
 		clc
@@ -840,11 +851,12 @@ func_all_w	.proc
 		bne  +
 		iny
 		lda  (c64.SCRATCH_ZPWORD1),y
-		bne  +
+		bne  ++
 		lda  #0
 		sta  c64.ESTACK_LO+1,x
 		rts
 +		iny
++		iny
 _cmp_mod	cpy  #255		; modified
 		bne  -
 		lda  #1
@@ -1372,3 +1384,290 @@ _mod2b          lda  #0                         ; self-modified
 _done		rts
 		.pend
 
+
+sort_ub		.proc
+		; 8bit unsigned sort
+		; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int)
+		; input:  address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1
+		; first, put pointer BEFORE array
+		lda  c64.SCRATCH_ZPWORD1
+		bne  +
+		dec  c64.SCRATCH_ZPWORD1+1
++		dec  c64.SCRATCH_ZPWORD1
+_sortloop	ldy  c64.SCRATCH_ZPB1		;start of subroutine sort
+		lda  (c64.SCRATCH_ZPWORD1),y	;last value in (what is left of) sequence to be sorted
+		sta  c64.SCRATCH_ZPREG		;save value. will be over-written by largest number
+		jmp  _l2
+_l1		dey
+		beq  _l3
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  c64.SCRATCH_ZPWORD2+1
+		bcc  _l1
+_l2		sty  c64.SCRATCH_ZPWORD2	;index of potentially largest value
+		sta  c64.SCRATCH_ZPWORD2+1	;potentially largest value
+		jmp  _l1
+_l3		ldy  c64.SCRATCH_ZPB1		;where the largest value shall be put
+		lda  c64.SCRATCH_ZPWORD2+1	;the largest value
+		sta  (c64.SCRATCH_ZPWORD1),y	;put largest value in place
+		ldy  c64.SCRATCH_ZPWORD2	;index of free space
+		lda  c64.SCRATCH_ZPREG		;the over-written value
+		sta  (c64.SCRATCH_ZPWORD1),y	;put the over-written value in the free space
+		dec  c64.SCRATCH_ZPB1		;end of the shorter sequence still left
+		bne  _sortloop			;start working with the shorter sequence
+		rts
+		.pend
+
+		
+sort_b		.proc
+		; 8bit signed sort
+		; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int)
+		; input:  address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1
+		; first, put pointer BEFORE array
+		lda  c64.SCRATCH_ZPWORD1
+		bne  +
+		dec  c64.SCRATCH_ZPWORD1+1
++		dec  c64.SCRATCH_ZPWORD1
+_sortloop	ldy  c64.SCRATCH_ZPB1		;start of subroutine sort
+		lda  (c64.SCRATCH_ZPWORD1),y	;last value in (what is left of) sequence to be sorted
+		sta  c64.SCRATCH_ZPREG		;save value. will be over-written by largest number
+		jmp  _l2
+_l1		dey
+		beq  _l3
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  c64.SCRATCH_ZPWORD2+1
+		bmi  _l1
+_l2		sty  c64.SCRATCH_ZPWORD2	;index of potentially largest value
+		sta  c64.SCRATCH_ZPWORD2+1	;potentially largest value
+		jmp  _l1
+_l3		ldy  c64.SCRATCH_ZPB1		;where the largest value shall be put
+		lda  c64.SCRATCH_ZPWORD2+1	;the largest value
+		sta  (c64.SCRATCH_ZPWORD1),y	;put largest value in place
+		ldy  c64.SCRATCH_ZPWORD2	;index of free space
+		lda  c64.SCRATCH_ZPREG		;the over-written value
+		sta  (c64.SCRATCH_ZPWORD1),y	;put the over-written value in the free space
+		dec  c64.SCRATCH_ZPB1		;end of the shorter sequence still left
+		bne  _sortloop			;start working with the shorter sequence
+		rts
+		.pend
+
+
+sort_uw		.proc
+		; 16bit unsigned sort
+		; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int)
+		; input:  address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1
+		; first: subtract 2 of the pointer
+		asl  c64.SCRATCH_ZPB1		; *2 because words
+		lda  c64.SCRATCH_ZPWORD1
+		sec
+		sbc  #2
+		sta  c64.SCRATCH_ZPWORD1
+		bcs  _sort_loop
+		dec  c64.SCRATCH_ZPWORD1+1
+_sort_loop	ldy  c64.SCRATCH_ZPB1    	;start of subroutine sort
+		lda  (c64.SCRATCH_ZPWORD1),y    ;last value in (what is left of) sequence to be sorted
+		sta  _work3          		;save value. will be over-written by largest number
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  _work3+1
+		dey
+		jmp  _l2
+_l1		dey  
+		dey
+		beq  _l3
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		dey
+		cmp  c64.SCRATCH_ZPWORD2+1
+		bne  +
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  c64.SCRATCH_ZPWORD2
++		bcc  _l1
+_l2		sty  _work1          		;index of potentially largest value
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.SCRATCH_ZPWORD2          ;potentially largest value
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.SCRATCH_ZPWORD2+1
+		dey
+		jmp  _l1
+_l3		ldy  c64.SCRATCH_ZPB1           ;where the largest value shall be put
+		lda  c64.SCRATCH_ZPWORD2          ;the largest value
+		sta  (c64.SCRATCH_ZPWORD1),y      ;put largest value in place
+		iny
+		lda  c64.SCRATCH_ZPWORD2+1
+		sta  (c64.SCRATCH_ZPWORD1),y
+		ldy  _work1         		 ;index of free space
+		lda  _work3          		;the over-written value
+		sta  (c64.SCRATCH_ZPWORD1),y      ;put the over-written value in the free space
+		iny
+		lda  _work3+1
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		dec  c64.SCRATCH_ZPB1           ;end of the shorter sequence still left
+		dec  c64.SCRATCH_ZPB1
+		bne  _sort_loop           ;start working with the shorter sequence
+		rts		
+_work1	.byte  0
+_work3	.word  0
+		.pend
+
+		
+sort_w		.proc
+		; 16bit signed sort
+		; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int)
+		; input:  address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1
+		; first: subtract 2 of the pointer
+		asl  c64.SCRATCH_ZPB1		; *2 because words
+		lda  c64.SCRATCH_ZPWORD1
+		sec
+		sbc  #2
+		sta  c64.SCRATCH_ZPWORD1
+		bcs  _sort_loop
+		dec  c64.SCRATCH_ZPWORD1+1
+_sort_loop	ldy  c64.SCRATCH_ZPB1    	;start of subroutine sort
+		lda  (c64.SCRATCH_ZPWORD1),y    ;last value in (what is left of) sequence to be sorted
+		sta  _work3          		;save value. will be over-written by largest number
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  _work3+1
+		dey
+		jmp  _l2
+_l1		dey  
+		dey
+		beq  _l3
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  c64.SCRATCH_ZPWORD2
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		dey
+		sbc  c64.SCRATCH_ZPWORD2+1
+		bvc  +
+		eor  #$80
++		bmi  _l1		
+_l2		sty  _work1          		;index of potentially largest value
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.SCRATCH_ZPWORD2          ;potentially largest value
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.SCRATCH_ZPWORD2+1
+		dey
+		jmp  _l1
+_l3		ldy  c64.SCRATCH_ZPB1           ;where the largest value shall be put
+		lda  c64.SCRATCH_ZPWORD2          ;the largest value
+		sta  (c64.SCRATCH_ZPWORD1),y      ;put largest value in place
+		iny
+		lda  c64.SCRATCH_ZPWORD2+1
+		sta  (c64.SCRATCH_ZPWORD1),y
+		ldy  _work1         		 ;index of free space
+		lda  _work3          		;the over-written value
+		sta  (c64.SCRATCH_ZPWORD1),y      ;put the over-written value in the free space
+		iny
+		lda  _work3+1
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		dec  c64.SCRATCH_ZPB1           ;end of the shorter sequence still left
+		dec  c64.SCRATCH_ZPB1
+		bne  _sort_loop           ;start working with the shorter sequence
+		rts		
+_work1	.byte  0
+_work3	.word  0
+		.pend		
+		
+		
+reverse_b	.proc
+		; --- reverse an array of bytes (in-place)
+		; inputs:  pointer to array in c64.SCRATCH_ZPWORD1, length in A
+_left_index = c64.SCRATCH_ZPWORD2
+_right_index = c64.SCRATCH_ZPWORD2+1
+		pha
+		sec
+		sbc  #1
+		sta  _left_index
+		lda  #0
+		sta  _right_index
+		pla
+		lsr  a
+		tay
+_loop		sty  c64.SCRATCH_ZPREG
+		ldy  _left_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		pla
+		ldy  _right_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _right_index
+		dec  _left_index
+		ldy  c64.SCRATCH_ZPREG
+		dey
+		bne  _loop
+		rts
+		.pend
+
+		
+reverse_w	.proc
+		; --- reverse an array of words (in-place)
+		; inputs:  pointer to array in c64.SCRATCH_ZPWORD1, length in A
+_left_index = c64.SCRATCH_ZPWORD2
+_right_index = c64.SCRATCH_ZPWORD2+1
+		pha
+		asl  a     ; *2 because words
+		sec
+		sbc  #2
+		sta  _left_index
+		lda  #0
+		sta  _right_index
+		pla
+		lsr  a
+		pha
+		tay
+		; first reverse the lsbs
+_loop_lo	sty  c64.SCRATCH_ZPREG
+		ldy  _left_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		pla
+		ldy  _right_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _right_index
+		inc  _right_index
+		dec  _left_index
+		dec  _left_index
+		ldy  c64.SCRATCH_ZPREG
+		dey
+		bne  _loop_lo
+		; now reverse the msbs
+		dec  _right_index
+		inc  _left_index
+		inc  _left_index
+		inc  _left_index
+		pla
+		tay
+_loop_hi	sty  c64.SCRATCH_ZPREG
+		ldy  _left_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		pla
+		ldy  _right_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dec  _right_index
+		dec  _right_index
+		inc  _left_index
+		inc  _left_index
+		ldy  c64.SCRATCH_ZPREG
+		dey
+		bne  _loop_hi
+
+		rts	
+		.pend

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,2 @@
-1.20
+1.60
+

compiler/src/prog8/CompilerMain.kt

@@ -1,21 +1,20 @@
 package prog8
 
+import prog8.ast.base.AstException
+import prog8.compiler.CompilationResult
 import prog8.compiler.compileProgram
+import prog8.parser.ParsingFailedError
 import prog8.vm.astvm.AstVm
-import prog8.vm.stackvm.stackVmMain
+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
 
 
 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,54 +32,93 @@ internal 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()
+    if(watchMode) {
+        if(moduleFile.isBlank())
+            usage()
 
-    val (programAst, programName) = compileProgram(filepath, optimize, optimizeInlining,
-            !launchAstVm, writeVmCode, writeAssembly)
+        val watchservice = FileSystems.getDefault().newWatchService()
 
-    if(launchAstVm) {
-        println("\nLaunching AST-based vm...")
-        val vm = AstVm(programAst)
-        vm.run()
-    }
+        while(true) {
+            val filepath = Paths.get(moduleFile).normalize()
+            println("Continuous watch mode active. Main module: $filepath")
 
-    if(emulatorToStart.isNotEmpty()) {
-        if(programName==null)
-            println("\nCan't start emulator because no program was assembled.")
-        else {
-            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()
+            try {
+                val compilationResult = compileProgram(filepath, optimize, writeAssembly)
+                println("Imported files (now watching:)")
+                for (importedFile in compilationResult.importedFiles) {
+                    print("  ")
+                    println(importedFile)
+                    importedFile.parent.register(watchservice, StandardWatchEventKinds.ENTRY_MODIFY)
+                }
+                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
+            }
+        }
+
+    } else {
+        if(moduleFile.isBlank())
+            usage()
+
+        val filepath = Paths.get(moduleFile).normalize()
+        val compilationResult: CompilationResult
+
+        try {
+            compilationResult = compileProgram(filepath, optimize, 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()
+            }
         }
     }
 }
@@ -88,14 +126,12 @@ private fun compileMain(args: Array<String>) {
 
 private fun usage() {
     System.err.println("Missing argument(s):")
+    System.err.println("    [-noasm]        don't create assembly code")
+    System.err.println("    [-noopt]        don't perform any 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("    [-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("    [-avm]          launch the prog8 ast-based virtual machine after compilation")
-    System.err.println("    [-noopt]        don't perform any optimizations")
-    System.err.println("    [-nooptinline]  don't perform subroutine inlining optimizations")
+    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/AstToSourceCode.kt

@@ -1,8 +1,5 @@
-package prog8.compiler
+package prog8.ast
 
-import prog8.ast.IFunctionCall
-import prog8.ast.Module
-import prog8.ast.Program
 import prog8.ast.antlr.escape
 import prog8.ast.base.DataType
 import prog8.ast.base.NumericDatatypes
@@ -11,6 +8,7 @@ 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
@@ -134,7 +132,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
             for(param in subroutine.parameters.zip(subroutine.asmParameterRegisters)) {
                 val reg =
                         when {
-                            true==param.second.stack -> "stack"
+                            param.second.stack -> "stack"
                             param.second.registerOrPair!=null -> param.second.registerOrPair.toString()
                             param.second.statusflag!=null -> param.second.statusflag.toString()
                             else -> "?????1"
@@ -258,15 +256,12 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         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(), '[', ']')
-                }
-            }
-        }
+    override fun visit(string: StringLiteralValue) {
+        output("\"${escape(string.value)}\"")
+    }
+
+    override fun visit(array: ArrayLiteralValue) {
+        outputListMembers(array.value.asSequence(), '[', ']')
     }
 
     private fun outputListMembers(array: Sequence<Expression>, openchar: Char, closechar: Char) {
@@ -320,13 +315,6 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
 
     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
@@ -345,7 +333,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(repeatLoop: RepeatLoop) {
-        outputln("repeat ")
+        output("repeat ")
         repeatLoop.body.accept(this)
         output(" until ")
         repeatLoop.untilCondition.accept(this)
@@ -429,13 +417,14 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     }
 
     override fun visit(whenChoice: WhenChoice) {
-        if(whenChoice.values==null)
+        val choiceValues = whenChoice.values
+        if(choiceValues==null)
             outputi("else -> ")
         else {
             outputi("")
-            for(value in whenChoice.values) {
+            for(value in choiceValues) {
                 value.accept(this)
-                if(value !== whenChoice.values.last())
+                if(value !== choiceValues.last())
                     output(",")
             }
             output(" -> ")

compiler/src/prog8/ast/AstToplevel.kt

@@ -168,9 +168,11 @@ class Program(val name: String, val modules: MutableList<Module>) {
     val namespace = GlobalNamespace(modules)
     val heap = HeapValues()
 
-    val loadAddress: Int
+    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)
@@ -181,6 +183,8 @@ class Program(val name: String, val modules: MutableList<Module>) {
             mainBlocks[0].subScopes()["start"] as Subroutine?
         }
     }
+
+    fun allBlocks(): List<Block> = modules.flatMap { it.statements.filterIsInstance<Block>() }
 }
 
 class Module(override val name: String,
@@ -236,7 +240,7 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
                 }
             }
         }
-
+        // lookup something from the module.
         val stmt = localContext.definingModule().lookup(scopedName, localContext)
         return when (stmt) {
             is Label, is VarDecl, is Block, is Subroutine -> stmt

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

@@ -429,7 +429,7 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     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.stringliteral()!=null -> StringLiteralValue(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())
@@ -438,10 +438,10 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     }
                 }
                 litval.arrayliteral()!=null -> {
-                    val array = litval.arrayliteral()?.toAst()
+                    val array = litval.arrayliteral().toAst()
                     // the actual type of the arraysize can not yet be determined here (missing namespace & heap)
-                    // the ConstantFolder takes care of that and converts the type if needed.
-                    ReferenceLiteralValue(DataType.ARRAY_UB, array = array, position = litval.toPosition())
+                    // the ConstantFold takes care of that and converts the type if needed.
+                    ArrayLiteralValue(DataType.ARRAY_UB, array, position = litval.toPosition())
                 }
                 litval.structliteral()!=null -> {
                     val values = litval.structliteral().expression().map { it.toAst() }
@@ -552,8 +552,6 @@ private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf
 
 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 =
@@ -561,7 +559,7 @@ private fun prog8Parser.ForloopContext.toAst(): ForLoop {
                 AnonymousScope(mutableListOf(statement().toAst()), statement().toPosition())
             else
                 AnonymousScope(statement_block().toAst(), statement_block().toPosition())
-    return ForLoop(loopregister, datatype, zeropage, loopvar, iterable, scope, toPosition())
+    return ForLoop(loopregister, loopvar, iterable, scope, toPosition())
 }
 
 
@@ -596,10 +594,10 @@ private fun prog8Parser.WhenstmtContext.toAst(): WhenStatement {
 private fun prog8Parser.When_choiceContext.toAst(): WhenChoice {
     val values = expression_list()?.toAst()
     val stmt = statement()?.toAst()
-    val stmt_block = statement_block()?.toAst()?.toMutableList() ?: mutableListOf()
+    val stmtBlock = statement_block()?.toAst()?.toMutableList() ?: mutableListOf()
     if(stmt!=null)
-        stmt_block.add(stmt)
-    val scope = AnonymousScope(stmt_block, toPosition())
+        stmtBlock.add(stmt)
+    val scope = AnonymousScope(stmtBlock, toPosition())
     return WhenChoice(values, scope, toPosition())
 }
 

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

@@ -1,6 +1,7 @@
 package prog8.ast.base
 
 import prog8.ast.Node
+import prog8.compiler.target.c64.MachineDefinition
 
 /**************************** AST Data classes ****************************/
 
@@ -25,10 +26,10 @@ enum class DataType {
     infix fun isAssignableTo(targetType: DataType) =
             // what types are assignable to others without loss of precision?
             when(this) {
-                UBYTE -> targetType in setOf(UBYTE, UWORD, WORD, FLOAT)
-                BYTE -> targetType in setOf(BYTE, UBYTE, UWORD, WORD, FLOAT)
+                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, UWORD, FLOAT)
+                WORD -> targetType in setOf(WORD, FLOAT)
                 FLOAT -> targetType == FLOAT
                 STR -> targetType == STR || targetType==STR_S
                 STR_S -> targetType == STR || targetType==STR_S
@@ -52,6 +53,16 @@ enum class DataType {
                 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 {
@@ -111,6 +122,8 @@ val IterableDatatypes = setOf(
 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,

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

@@ -10,13 +10,13 @@ class SyntaxError(override var message: String, val position: Position) : AstExc
     override fun toString() = "$position Syntax error: $message"
 }
 
-class NameError(override var message: String, val position: Position) : AstException(message) {
+open 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) {
+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)
+    : NameError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)

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

@@ -4,6 +4,7 @@ import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.processing.*
 import prog8.compiler.CompilationOptions
+import prog8.compiler.target.c64.codegen.AnonymousScopeVarsCleanup
 import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
 
 
@@ -11,10 +12,6 @@ import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
 internal const val initvarsSubName="prog8_init_vars"
 
 
-// prefix for literal values that are turned into a variable on the heap
-internal const val autoHeapValuePrefix = "auto_heap_value_"
-
-
 internal fun Program.removeNopsFlattenAnonScopes() {
     val flattener = FlattenAnonymousScopesAndRemoveNops()
     flattener.visit(this)
@@ -28,14 +25,26 @@ internal fun Program.checkValid(compilerOptions: CompilationOptions) {
 }
 
 
+internal fun Program.anonscopeVarsCleanup() {
+    val mover = AnonymousScopeVarsCleanup(this)
+    mover.visit(this)
+    printErrors(mover.result(), name)
+}
+
+
 internal fun Program.reorderStatements() {
-    val initvalueCreator = VarInitValueAndAddressOfCreator(namespace, heap)
+    val initvalueCreator = VarInitValueAndAddressOfCreator(this)
     initvalueCreator.visit(this)
 
     val checker = StatementReorderer(this)
     checker.visit(this)
 }
 
+internal fun Program.addTypecasts() {
+    val caster = TypecastsAdder(this)
+    caster.visit(this)
+}
+
 internal fun Module.checkImportedValid() {
     val checker = ImportedModuleDirectiveRemover()
     checker.visit(this)

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

@@ -18,6 +18,7 @@ import prog8.compiler.target.c64.Petscii
 import prog8.functions.BuiltinFunctions
 import prog8.functions.NotConstArgumentException
 import prog8.functions.builtinFunctionReturnType
+import java.util.*
 import kotlin.math.abs
 
 
@@ -28,8 +29,8 @@ 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?
+    abstract fun referencesIdentifiers(vararg name: String): Boolean     // todo: remove this and add identifier usage tracking into CallGraph instead
+    abstract fun inferType(program: Program): InferredTypes.InferredType
 
     infix fun isSameAs(other: Expression): Boolean {
         if(this===other)
@@ -67,7 +68,7 @@ class PrefixExpression(val operator: String, var expression: Expression, overrid
     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 inferType(program: Program): InferredTypes.InferredType = expression.inferType(program)
 
     override fun toString(): String {
         return "Prefix($operator $expression)"
@@ -93,162 +94,97 @@ class BinaryExpression(var left: Expression, var operator: String, var right: Ex
     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? {
+    override fun inferType(program: Program): InferredTypes.InferredType {
         val leftDt = left.inferType(program)
         val rightDt = right.inferType(program)
         return when (operator) {
-            "+", "-", "*", "**", "%" -> if (leftDt == null || rightDt == null) null else {
-                try {
-                    arithmeticOpDt(leftDt, rightDt)
-                } catch (x: FatalAstException) {
-                    null
+            "+", "-", "*", "**", "%", "/" -> {
+                if (!leftDt.isKnown || !rightDt.isKnown)
+                    InferredTypes.unknown()
+                else {
+                    try {
+                        InferredTypes.knownFor(commonDatatype(
+                                leftDt.typeOrElse(DataType.BYTE),
+                                rightDt.typeOrElse(DataType.BYTE),
+                                null, null).first)
+                    } catch (x: FatalAstException) {
+                        InferredTypes.unknown()
+                    }
                 }
             }
-            "/" -> if (leftDt == null || rightDt == null) null else divisionOpDt(leftDt, rightDt)
             "&" -> leftDt
             "|" -> leftDt
             "^" -> leftDt
             "and", "or", "xor",
             "<", ">",
             "<=", ">=",
-            "==", "!=" -> DataType.UBYTE
+            "==", "!=" -> InferredTypes.knownFor(DataType.UBYTE)
             "<<", ">>" -> leftDt
             else -> throw FatalAstException("resulting datatype check for invalid operator $operator")
         }
     }
 
     companion object {
-        fun divisionOpDt(leftDt: DataType, rightDt: DataType): DataType {
+        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, DataType.UWORD -> DataType.UBYTE
-                    DataType.BYTE, DataType.WORD -> DataType.WORD
-                    DataType.FLOAT -> DataType.BYTE
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                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) {
-                    in NumericDatatypes -> DataType.BYTE
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                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, DataType.UWORD -> DataType.UWORD
-                    DataType.BYTE, DataType.WORD -> DataType.WORD
-                    DataType.FLOAT -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                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) {
-                    in NumericDatatypes -> DataType.WORD
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                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 -> when (rightDt) {
-                    in NumericDatatypes -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                DataType.FLOAT -> {
+                    Pair(DataType.FLOAT, right)
                 }
-                else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                else -> Pair(leftDt, null)      // non-numeric datatype
             }
         }
-
-        fun arithmeticOpDt(leftDt: DataType, rightDt: DataType): DataType {
-            return when (leftDt) {
-                DataType.UBYTE -> when (rightDt) {
-                    DataType.UBYTE -> DataType.UBYTE
-                    DataType.BYTE -> DataType.BYTE
-                    DataType.UWORD -> DataType.UWORD
-                    DataType.WORD -> DataType.WORD
-                    DataType.FLOAT -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-                }
-                DataType.BYTE -> when (rightDt) {
-                    in ByteDatatypes -> DataType.BYTE
-                    in WordDatatypes -> DataType.WORD
-                    DataType.FLOAT -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-                }
-                DataType.UWORD -> when (rightDt) {
-                    DataType.UBYTE, DataType.UWORD -> DataType.UWORD
-                    DataType.BYTE, DataType.WORD -> DataType.WORD
-                    DataType.FLOAT -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-                }
-                DataType.WORD -> when (rightDt) {
-                    in IntegerDatatypes -> DataType.WORD
-                    DataType.FLOAT -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-                }
-                DataType.FLOAT -> when (rightDt) {
-                    in NumericDatatypes -> DataType.FLOAT
-                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-                }
-                else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
-            }
-        }
-    }
-
-    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!)
-
-        if(this.operator=="/") {
-            // division is a bit weird, don't cast the operands
-            val commondt = divisionOpDt(leftDt, rightDt)
-            return Pair(commondt, null)
-        }
-
-        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.UWORD, 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(val identifier: IdentifierReference,
-                             var arrayspec: ArrayIndex,
+class ArrayIndexedExpression(var identifier: IdentifierReference,
+                             val arrayspec: ArrayIndex,
                              override val position: Position) : Expression() {
     override lateinit var parent: Node
     override fun linkParents(parent: Node) {
@@ -262,17 +198,16 @@ class ArrayIndexedExpression(val identifier: IdentifierReference,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun referencesIdentifiers(vararg name: String) = identifier.referencesIdentifiers(*name)
 
-    override fun inferType(program: Program): DataType? {
+    override fun inferType(program: Program): InferredTypes.InferredType {
         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")
+                in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE)
+                in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(target.datatype))
+                else -> InferredTypes.unknown()
             }
         }
-        return null
+        return InferredTypes.unknown()
     }
 
     override fun toString(): String {
@@ -291,7 +226,7 @@ class TypecastExpression(var expression: Expression, var type: DataType, val imp
     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 inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
     override fun constValue(program: Program): NumericLiteralValue? {
         val cv = expression.constValue(program) ?: return null
         return cv.cast(type)
@@ -304,7 +239,7 @@ class TypecastExpression(var expression: Expression, var type: DataType, val imp
     }
 }
 
-data class AddressOf(val identifier: IdentifierReference, override val position: Position) : Expression() {
+data class AddressOf(var identifier: IdentifierReference, override val position: Position) : Expression() {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
@@ -312,10 +247,9 @@ data class AddressOf(val identifier: IdentifierReference, override val position:
         identifier.parent=this
     }
 
-    var scopedname: String? = null     // will be set in a later state by the compiler
     override fun constValue(program: Program): NumericLiteralValue? = null
     override fun referencesIdentifiers(vararg name: String) = false
-    override fun inferType(program: Program) = DataType.UWORD
+    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UWORD)
     override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
 }
@@ -331,7 +265,7 @@ class DirectMemoryRead(var addressExpression: Expression, override val position:
     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 inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
     override fun constValue(program: Program): NumericLiteralValue? = null
 
     override fun toString(): String {
@@ -367,6 +301,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
                 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")
             }
         }
@@ -386,9 +321,9 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
 
     override fun toString(): String = "NumericLiteral(${type.name}:$number)"
 
-    override fun inferType(program: Program) = type
+    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
 
-    override fun hashCode(): Int  = type.hashCode() * 31 xor number.hashCode()
+    override fun hashCode(): Int = Objects.hash(type, number)
 
     override fun equals(other: Any?): Boolean {
         if(other==null || other !is NumericLiteralValue)
@@ -398,7 +333,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
 
     operator fun compareTo(other: NumericLiteralValue): Int = number.toDouble().compareTo(other.number.toDouble())
 
-    fun cast(targettype: DataType): NumericLiteralValue? {
+    fun cast(targettype: DataType): NumericLiteralValue {
         if(type==targettype)
             return this
         val numval = number.toDouble()
@@ -453,7 +388,7 @@ class NumericLiteralValue(val type: DataType,    // only numerical types allowed
             }
             else -> {}
         }
-        return null    // invalid type conversion from $this to $targettype
+        throw ExpressionError("can't cast $type into $targettype", position)
     }
 }
 
@@ -470,110 +405,105 @@ class StructLiteralValue(var values: List<Expression>,
     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 inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(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() {
+class StringLiteralValue(val type: DataType,     // only string types
+                         val value: String,
+                         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 && heapId==null) throw FatalAstException("literal value missing strvalue/heapId")
-            in ArrayDatatypes ->
-                if(array==null && heapId==null) throw FatalAstException("literal value missing arrayvalue/heapId")
-            else -> throw FatalAstException("invalid type $type")
-        }
-        if(array==null && str==null && heapId==null)
-            throw FatalAstException("literal ref value without actual value")
+    override fun linkParents(parent: Node) {
+        this.parent = parent
     }
+    override fun referencesIdentifiers(vararg name: String) = false
+    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 toString(): String = "'${escape(value)}'"
+    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
+    operator fun compareTo(other: StringLiteralValue): Int = value.compareTo(other.value)
+    override fun hashCode(): Int = Objects.hash(value, type)
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is StringLiteralValue)
+            return false
+        return value==other.value && type==other.type
+    }
+
+    fun addToHeap(heap: HeapValues) {
+        if (heapId != null)
+            return
+        else
+            heapId = heap.addString(type, value)
+    }
+}
+
+class ArrayLiteralValue(val type: DataType,     // only array types
+                        val value: Array<Expression>,
+                        initHeapId: Int? =null,
+                        override val position: Position) : Expression() {
+    override lateinit var parent: Node
+
+    var heapId = initHeapId
+        private set
 
     override fun linkParents(parent: Node) {
         this.parent = parent
-        array?.forEach {it.linkParents(this)}
+        value.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 referencesIdentifiers(vararg name: String) = value.any { it.referencesIdentifiers(*name) }
+    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 toString(): String {
-        val valueStr = when(type) {
-            in StringDatatypes -> "'${escape(str!!)}'"
-            in ArrayDatatypes -> "$array"
-            else -> throw FatalAstException("weird ref type")
-        }
-        return "ReferenceValueLiteral($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 toString(): String = "$value"
+    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
+    operator fun compareTo(other: ArrayLiteralValue): Int = throw ExpressionError("cannot order compare arrays", position)
+    override fun hashCode(): Int = Objects.hash(value, type)
     override fun equals(other: Any?): Boolean {
-        if(other==null || other !is ReferenceLiteralValue)
+        if(other==null || other !is ArrayLiteralValue)
             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
+        return type==other.type && value.contentEquals(other.value)
     }
 
-    operator fun compareTo(other: ReferenceLiteralValue): Int {
-        throw ExpressionError("cannot order compare type $type with ${other.type}", other.position)
-    }
-
-    fun cast(targettype: DataType): ReferenceLiteralValue? {
+    fun cast(targettype: DataType): ArrayLiteralValue? {
         if(type==targettype)
             return this
-        when(type) {
-            in StringDatatypes -> {
-                if(targettype in StringDatatypes)
-                    return ReferenceLiteralValue(targettype, str, initHeapId = heapId, position = position)
-            }
-            else -> {}
+        if(targettype in ArrayDatatypes) {
+            val elementType = ArrayElementTypes.getValue(targettype)
+            val castArray = value.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 {
+                    try {
+                        num.cast(elementType)
+                    } catch(x: ExpressionError) {
+                        return null
+                    }
+                }
+            }.toTypedArray()
+            return ArrayLiteralValue(targettype, castArray, position = position)
         }
         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 {
+        if (heapId != null)
+            return
+        else {
+            if(value.any {it is AddressOf }) {
+                val intArrayWithAddressOfs = value.map {
                     when (it) {
                         is AddressOf -> IntegerOrAddressOf(null, it)
                         is NumericLiteralValue -> IntegerOrAddressOf(it.number.toInt(), null)
@@ -582,13 +512,15 @@ class ReferenceLiteralValue(val type: DataType,     // only reference types allo
                 }
                 heapId = heap.addIntegerArray(type, intArrayWithAddressOfs.toTypedArray())
             } else {
-                val valuesInArray = array.map { (it as NumericLiteralValue).number }
-                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())
+                val valuesInArray = value.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())
+                    }
                 }
             }
         }
@@ -612,18 +544,18 @@ class RangeExpr(var from: Expression,
     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? {
+    override fun inferType(program: Program): InferredTypes.InferredType {
         val fromDt=from.inferType(program)
         val toDt=to.inferType(program)
         return when {
-            fromDt==null || toDt==null -> null
-            fromDt== DataType.UBYTE && toDt== DataType.UBYTE -> DataType.UBYTE
-            fromDt== DataType.UWORD && toDt== DataType.UWORD -> DataType.UWORD
-            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.WORD
-            fromDt== DataType.BYTE || toDt== DataType.BYTE -> DataType.BYTE
-            else -> DataType.UBYTE
+            !fromDt.isKnown || !toDt.isKnown -> InferredTypes.unknown()
+            fromDt istype DataType.UBYTE && toDt istype DataType.UBYTE -> InferredTypes.knownFor(DataType.ARRAY_UB)
+            fromDt istype DataType.UWORD && toDt istype DataType.UWORD -> InferredTypes.knownFor(DataType.ARRAY_UW)
+            fromDt istype DataType.STR && toDt istype DataType.STR -> InferredTypes.knownFor(DataType.STR)
+            fromDt istype DataType.STR_S && toDt istype DataType.STR_S -> InferredTypes.knownFor(DataType.STR_S)
+            fromDt istype DataType.WORD || toDt istype DataType.WORD -> InferredTypes.knownFor(DataType.ARRAY_W)
+            fromDt istype DataType.BYTE || toDt istype DataType.BYTE -> InferredTypes.knownFor(DataType.ARRAY_B)
+            else -> InferredTypes.knownFor(DataType.ARRAY_UB)
         }
     }
     override fun toString(): String {
@@ -641,12 +573,12 @@ class RangeExpr(var from: Expression,
     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) {
+        val fromString = from as? StringLiteralValue
+        val toString = to as? StringLiteralValue
+        if(fromString!=null && toString!=null ) {
             // string range -> int range over petscii values
-            fromVal = Petscii.encodePetscii(fromRlv.str!!, true)[0].toInt()
-            toVal = Petscii.encodePetscii(toRlv.str!!, true)[0].toInt()
+            fromVal = Petscii.encodePetscii(fromString.value, true)[0].toInt()
+            toVal = Petscii.encodePetscii(toString.value, true)[0].toInt()
         } else {
             val fromLv = from as? NumericLiteralValue
             val toLv = to as? NumericLiteralValue
@@ -657,17 +589,21 @@ class RangeExpr(var from: Expression,
             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)
-            }
+        return makeRange(fromVal, toVal, stepVal)
+    }
+}
+
+internal fun makeRange(fromVal: Int, toVal: Int, stepVal: Int): IntProgression {
+    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)
         }
     }
 }
@@ -687,7 +623,7 @@ class RegisterExpr(val register: Register, override val position: Position) : Ex
         return "RegisterExpr(register=$register, pos=$position)"
     }
 
-    override fun inferType(program: Program) = DataType.UBYTE
+    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
 }
 
 data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : Expression() {
@@ -724,23 +660,26 @@ data class IdentifierReference(val nameInSource: List<String>, override val posi
 
     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 referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name
 
-    override fun inferType(program: Program): DataType? {
+    override fun inferType(program: Program): InferredTypes.InferredType {
         val targetStmt = targetStatement(program.namespace)
         if(targetStmt is VarDecl) {
-            return targetStmt.datatype
+            return InferredTypes.knownFor(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")
+            is StringLiteralValue -> value.heapId ?: throw FatalAstException("string is not on the heap: $value")
+            is ArrayLiteralValue -> value.heapId ?: throw FatalAstException("array is not on the heap: $value")
             else -> throw FatalAstException("requires a reference value")
         }
     }
@@ -776,7 +715,7 @@ class FunctionCall(override var target: IdentifierReference,
 
             if(withDatatypeCheck) {
                 val resultDt = this.inferType(program)
-                if(resultValue==null || resultDt == resultValue.type)
+                if(resultValue==null || resultDt istype resultValue.type)
                     return resultValue
                 throw FatalAstException("evaluated const expression result value doesn't match expected datatype $resultDt, pos=$position")
             } else {
@@ -797,27 +736,27 @@ class FunctionCall(override var target: IdentifierReference,
     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? {
+    override fun inferType(program: Program): InferredTypes.InferredType {
         val constVal = constValue(program ,false)
         if(constVal!=null)
-            return constVal.type
-        val stmt = target.targetStatement(program.namespace) ?: return null
+            return InferredTypes.knownFor(constVal.type)
+        val stmt = target.targetStatement(program.namespace) ?: return InferredTypes.unknown()
         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 InferredTypes.void() // these have no return value
                 }
                 return builtinFunctionReturnType(target.nameInSource[0], this.arglist, program)
             }
             is Subroutine -> {
                 if(stmt.returntypes.isEmpty())
-                    return null     // no return value
+                    return InferredTypes.void()     // 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
+                    return InferredTypes.knownFor(stmt.returntypes[0])
+                return InferredTypes.unknown()     // has multiple return types... so not a single resulting datatype possible
             }
-            else -> return null
+            else -> return InferredTypes.unknown()
         }
     }
 }

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

@@ -0,0 +1,58 @@
+package prog8.ast.expressions
+
+import prog8.ast.base.DataType
+
+object InferredTypes {
+    class InferredType private constructor(val isUnknown: Boolean, val isVoid: Boolean, private var datatype: DataType?) {
+        init {
+            if(datatype!=null && (isUnknown || isVoid))
+                throw IllegalArgumentException("invalid combination of args")
+        }
+
+        val isKnown = datatype!=null
+        fun typeOrElse(alternative: DataType) = if(isUnknown || isVoid) alternative else datatype!!
+        infix fun istype(type: DataType): Boolean = if(isUnknown || isVoid) false else this.datatype==type
+
+        companion object {
+            fun unknown() = InferredType(isUnknown = true, isVoid = false, datatype = null)
+            fun void() = InferredType(isUnknown = false, isVoid = true, datatype = null)
+            fun known(type: DataType) = InferredType(isUnknown = false, isVoid = false, datatype = type)
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if(other !is InferredType)
+                return false
+            return isVoid==other.isVoid && datatype==other.datatype
+        }
+
+        override fun toString(): String {
+            return when {
+                datatype!=null -> datatype.toString()
+                isVoid -> "<void>"
+                else -> "<unkonwn>"
+            }
+        }
+    }
+
+    private val unknownInstance = InferredType.unknown()
+    private val voidInstance = InferredType.void()
+    private val knownInstances = mapOf(
+            DataType.UBYTE to InferredType.known(DataType.UBYTE),
+            DataType.BYTE to InferredType.known(DataType.BYTE),
+            DataType.UWORD to InferredType.known(DataType.UWORD),
+            DataType.WORD to InferredType.known(DataType.WORD),
+            DataType.FLOAT to InferredType.known(DataType.FLOAT),
+            DataType.STR to InferredType.known(DataType.STR),
+            DataType.STR_S to InferredType.known(DataType.STR_S),
+            DataType.ARRAY_UB to InferredType.known(DataType.ARRAY_UB),
+            DataType.ARRAY_B to InferredType.known(DataType.ARRAY_B),
+            DataType.ARRAY_UW to InferredType.known(DataType.ARRAY_UW),
+            DataType.ARRAY_W to InferredType.known(DataType.ARRAY_W),
+            DataType.ARRAY_F to InferredType.known(DataType.ARRAY_F),
+            DataType.STRUCT to InferredType.known(DataType.STRUCT)
+    )
+
+    fun void() = voidInstance
+    fun unknown() = unknownInstance
+    fun knownFor(type: DataType) = knownInstances.getValue(type)
+}

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

@@ -1,5 +1,6 @@
 package prog8.ast.processing
 
+import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Module
 import prog8.ast.Program
@@ -7,7 +8,6 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.CompilationOptions
-import prog8.compiler.HeapValues
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
 import prog8.functions.BuiltinFunctions
@@ -98,25 +98,36 @@ internal class AstChecker(private val program: Program,
         }
         if(expectedReturnValues.size==1 && returnStmt.value!=null) {
             val valueDt = returnStmt.value!!.inferType(program)
-            if(expectedReturnValues[0]!=valueDt)
-                checkResult.add(ExpressionError("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position))
+            if(!valueDt.isKnown) {
+                checkResult.add(ExpressionError("return value type mismatch", returnStmt.value!!.position))
+            } else {
+                if (expectedReturnValues[0] != valueDt.typeOrElse(DataType.STRUCT))
+                    checkResult.add(ExpressionError("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position))
+            }
         }
         super.visit(returnStmt)
     }
 
+    override fun visit(ifStatement: IfStatement) {
+        if(ifStatement.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
+            checkResult.add(ExpressionError("condition value should be an integer type", ifStatement.condition.position))
+        super.visit(ifStatement)
+    }
+
     override fun visit(forLoop: ForLoop) {
         if(forLoop.body.containsNoCodeNorVars())
             printWarning("for loop body is empty", forLoop.position)
 
-        val iterableDt = forLoop.iterable.inferType(program)
+        val iterableDt = forLoop.iterable.inferType(program).typeOrElse(DataType.BYTE)
         if(iterableDt !in IterableDatatypes && forLoop.iterable !is RangeExpr) {
             checkResult.add(ExpressionError("can only loop over an iterable type", forLoop.position))
         } else {
             if (forLoop.loopRegister != null) {
-                printWarning("using a register as loop variable is risky (it could get clobbered)", forLoop.position)
                 // loop register
-                if (iterableDt != DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt !in StringDatatypes)
+                if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt !in StringDatatypes)
                     checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position))
+                if(forLoop.loopRegister!=Register.A)
+                    checkResult.add(ExpressionError("it's only possible to use A as a loop register", forLoop.position))
             } else {
                 // loop variable
                 val loopvar = forLoop.loopVar!!.targetVarDecl(program.namespace)
@@ -143,14 +154,14 @@ internal class AstChecker(private val program: Program,
                                 checkResult.add(ExpressionError("word loop variable can only loop over bytes or words", forLoop.position))
                         }
                         DataType.FLOAT -> {
-                            if(iterableDt!= DataType.FLOAT && iterableDt != DataType.ARRAY_F)
-                                checkResult.add(ExpressionError("float loop variable can only loop over floats", forLoop.position))
+                            checkResult.add(ExpressionError("for loop only supports integers", forLoop.position))
                         }
                         else -> checkResult.add(ExpressionError("loop variable must be numeric type", forLoop.position))
                     }
                 }
             }
         }
+
         super.visit(forLoop)
     }
 
@@ -297,15 +308,24 @@ internal class AstChecker(private val program: Program,
 
             if(subroutine.asmClobbers.intersect(regCounts.keys).isNotEmpty())
                 err("a return register is also in the clobber list")
+
+            if(subroutine.statements.any{it !is InlineAssembly})
+                err("asmsub can only contain inline assembly (%asm)")
+
+            val statusFlagsNoCarry = subroutine.asmParameterRegisters.mapNotNull { it.statusflag }.toSet() - Statusflag.Pc
+            if(statusFlagsNoCarry.isNotEmpty())
+                err("can only use Carry as status flag parameter")
+
+            val carryParameter = subroutine.asmParameterRegisters.singleOrNull { it.statusflag==Statusflag.Pc }
+            if(carryParameter!=null && carryParameter !== subroutine.asmParameterRegisters.last())
+                err("carry parameter has to come last")
+
         } else {
-            // TODO: non-asm subroutines can only take numeric arguments for now. (not strings and arrays) Maybe this can be improved now that we have '&' ?
-            // the way string params are treated is almost okay (their address is passed) but the receiving subroutine treats it as an integer rather than referring back to the original string.
-            // the way array params are treated is buggy; it thinks the subroutine needs a byte parameter in place of a byte[] ...
-            // This is not easy to fix because strings and arrays are treated a bit simplistic (a "virtual" pointer to the value on the heap)
-            // while passing them as subroutine parameters would require a "real" pointer OR copying the VALUE to the subroutine's parameter variable (which is very inefficient).
-            // For now, don't pass strings and arrays as parameters and instead create the workaround as suggested in the error message below.
-            if(!subroutine.parameters.all{it.type in NumericDatatypes }) {
-                err("Non-asm subroutine can only take numerical parameters (no str/array types) for now. Workaround (for nested subroutine): access the variable from the outer scope directly.")
+            // Pass-by-reference datatypes can not occur as parameters to a subroutine directly
+            // Instead, their reference (address) should be passed (as an UWORD).
+            // The language has no typed pointers at this time.
+            if(subroutine.parameters.any{it.type in PassByReferenceDatatypes }) {
+                err("Pass-by-reference types (str, array) cannot occur as a parameter type directly. Instead, use an uword for their address, or access the variable from the outer scope directly.")
             }
         }
     }
@@ -313,12 +333,16 @@ internal class AstChecker(private val program: Program,
     override fun visit(repeatLoop: RepeatLoop) {
         if(repeatLoop.untilCondition.referencesIdentifiers("A", "X", "Y"))
             printWarning("using a register in the loop condition is risky (it could get clobbered)", repeatLoop.untilCondition.position)
+        if(repeatLoop.untilCondition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
+            checkResult.add(ExpressionError("condition value should be an integer type", repeatLoop.untilCondition.position))
         super.visit(repeatLoop)
     }
 
     override fun visit(whileLoop: WhileLoop) {
         if(whileLoop.condition.referencesIdentifiers("A", "X", "Y"))
             printWarning("using a register in the loop condition is risky (it could get clobbered)", whileLoop.condition.position)
+        if(whileLoop.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
+            checkResult.add(ExpressionError("condition value should be an integer type", whileLoop.condition.position))
         super.visit(whileLoop)
     }
 
@@ -331,7 +355,8 @@ internal class AstChecker(private val program: Program,
                 if(stmt.returntypes.size>1)
                     checkResult.add(ExpressionError("It's not possible to store the multiple results of this asmsub call; you should use a small block of custom inline assembly for this.", assignment.value.position))
                 else {
-                    if(stmt.returntypes.single()!=assignment.target.inferType(program, assignment)) {
+                    val idt = assignment.target.inferType(program, assignment)
+                    if(!idt.isKnown || stmt.returntypes.single()!=idt.typeOrElse(DataType.BYTE)) {
                          checkResult.add(ExpressionError("return type mismatch", assignment.value.position))
                     }
                 }
@@ -353,6 +378,8 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(assignTarget: AssignTarget) {
+        super.visit(assignTarget)
+
         val memAddr = assignTarget.memoryAddress?.addressExpression?.constValue(program)?.number?.toInt()
         if (memAddr != null) {
             if (memAddr < 0 || memAddr >= 65536)
@@ -360,12 +387,13 @@ internal class AstChecker(private val program: Program,
         }
 
         val assignment = assignTarget.parent as Statement
-        if (assignTarget.identifier != null) {
-            val targetName = assignTarget.identifier.nameInSource
+        val targetIdentifier = assignTarget.identifier
+        if (targetIdentifier != null) {
+            val targetName = targetIdentifier.nameInSource
             val targetSymbol = program.namespace.lookup(targetName, assignment)
             when (targetSymbol) {
                 null -> {
-                    checkResult.add(ExpressionError("undefined symbol: ${targetName.joinToString(".")}", assignment.position))
+                    checkResult.add(UndefinedSymbolError(targetIdentifier))
                     return
                 }
                 !is VarDecl -> {
@@ -380,6 +408,9 @@ internal class AstChecker(private val program: Program,
                 }
             }
         }
+        val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
+        if(targetDt in StringDatatypes || targetDt in ArrayDatatypes)
+            checkResult.add(SyntaxError("cannot assign to a string or array type", assignTarget.position))
 
         if (assignment is Assignment) {
 
@@ -387,13 +418,13 @@ internal class AstChecker(private val program: Program,
                 throw FatalAstException("augmented assignment should have been converted into normal assignment")
 
             val targetDatatype = assignTarget.inferType(program, assignment)
-            if (targetDatatype != null) {
+            if (targetDatatype.isKnown) {
                 val constVal = assignment.value.constValue(program)
                 if (constVal != null) {
-                    checkValueTypeAndRange(targetDatatype, constVal)
+                    checkValueTypeAndRange(targetDatatype.typeOrElse(DataType.BYTE), constVal)
                 } else {
-                    val sourceDatatype: DataType? = assignment.value.inferType(program)
-                    if (sourceDatatype == null) {
+                    val sourceDatatype = assignment.value.inferType(program)
+                    if (!sourceDatatype.isKnown) {
                         if (assignment.value is FunctionCall) {
                             val targetStmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
                             if (targetStmt != null)
@@ -401,7 +432,8 @@ internal class AstChecker(private val program: Program,
                         } else
                             checkResult.add(ExpressionError("assignment value is invalid or has no proper datatype", assignment.value.position))
                     } else {
-                        checkAssignmentCompatible(targetDatatype, assignTarget, sourceDatatype, assignment.value, assignment.position)
+                        checkAssignmentCompatible(targetDatatype.typeOrElse(DataType.BYTE), assignTarget,
+                                sourceDatatype.typeOrElse(DataType.BYTE), assignment.value, assignment.position)
                     }
                 }
             }
@@ -416,8 +448,6 @@ internal class AstChecker(private val program: Program,
             if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes && variable.datatype!=DataType.STRUCT)
                 checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position))
         }
-        if(addressOf.scopedname==null)
-            throw FatalAstException("the scopedname of AddressOf should have been set by now  $addressOf")
         super.visit(addressOf)
     }
 
@@ -502,14 +532,12 @@ internal class AstChecker(private val program: Program,
                 }
                 when(decl.value) {
                     is RangeExpr -> throw FatalAstException("range expression should have been converted to a true array value")
-                    is ReferenceLiteralValue -> {
-                        val arraySpec = decl.arraysize ?: (
-                                if((decl.value as ReferenceLiteralValue).isArray)
-                                    ArrayIndex.forArray(decl.value as ReferenceLiteralValue, program.heap)
-                                else
-                                    ArrayIndex(NumericLiteralValue.optimalInteger(-2, decl.position), decl.position)
-                                )
-                        checkValueTypeAndRange(decl.datatype, decl.struct, arraySpec, decl.value as ReferenceLiteralValue, program.heap)
+                    is StringLiteralValue -> {
+                        checkValueTypeAndRangeString(decl.datatype, decl.value as StringLiteralValue)
+                    }
+                    is ArrayLiteralValue -> {
+                        val arraySpec = decl.arraysize ?: ArrayIndex.forArray(decl.value as ArrayLiteralValue)
+                        checkValueTypeAndRangeArray(decl.datatype, decl.struct, arraySpec, decl.value as ArrayLiteralValue)
                     }
                     is NumericLiteralValue -> {
                         checkValueTypeAndRange(decl.datatype, decl.value as NumericLiteralValue)
@@ -596,8 +624,9 @@ internal class AstChecker(private val program: Program,
                         directive.args[0].name != "basicsafe" &&
                         directive.args[0].name != "floatsafe" &&
                         directive.args[0].name != "kernalsafe" &&
+                        directive.args[0].name != "dontuse" &&
                         directive.args[0].name != "full")
-                    err("invalid zp type, expected basicsafe, floatsafe, kernalsafe, or full")
+                    err("invalid zp type, expected basicsafe, floatsafe, kernalsafe, dontuse, or full")
             }
             "%zpreserved" -> {
                 if(directive.parent !is Module) err("this directive may only occur at module level")
@@ -631,11 +660,11 @@ internal class AstChecker(private val program: Program,
                 if(directive.parent !is INameScope || directive.parent is Module) err("this directive may only occur in a block")
                 val errormsg = "invalid asmbinary directive, expected arguments: \"filename\" [, offset [, length ] ]"
                 if(directive.args.isEmpty()) err(errormsg)
-                if(directive.args.isNotEmpty() && directive.args[0].str==null) err(errormsg)
-                if(directive.args.size>=2 && directive.args[1].int==null) err(errormsg)
-                if(directive.args.size==3 && directive.args[2].int==null) err(errormsg)
-                if(directive.args.size>3) err(errormsg)
-                checkFileExists(directive, directive.args[0].str!!)
+                else if(directive.args.isNotEmpty() && directive.args[0].str==null) err(errormsg)
+                else if(directive.args.size>=2 && directive.args[1].int==null) err(errormsg)
+                else if(directive.args.size==3 && directive.args[2].int==null) err(errormsg)
+                else if(directive.args.size>3) err(errormsg)
+                else checkFileExists(directive, directive.args[0].str!!)
             }
             "%option" -> {
                 if(directive.parent !is Block && directive.parent !is Module) err("this directive may only occur in a block or at module level")
@@ -657,35 +686,29 @@ internal class AstChecker(private val program: Program,
             checkResult.add(NameError("included file not found: $filename", directive.position))
     }
 
-    override fun visit(refLiteral: ReferenceLiteralValue) {
-        if(!compilerOptions.floats && refLiteral.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
-            checkResult.add(SyntaxError("floating point used, but that is not enabled via options", refLiteral.position))
+    override fun visit(array: ArrayLiteralValue) {
+        if(!compilerOptions.floats && array.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
+            checkResult.add(SyntaxError("floating point used, but that is not enabled via options", array.position))
         }
-        val arrayspec =
-                if(refLiteral.isArray)
-                    ArrayIndex.forArray(refLiteral, program.heap)
-                else
-                    ArrayIndex(NumericLiteralValue.optimalInteger(-3, refLiteral.position), refLiteral.position)
-        checkValueTypeAndRange(refLiteral.type, null, arrayspec, refLiteral, program.heap)
+        val arrayspec = ArrayIndex.forArray(array)
+        checkValueTypeAndRangeArray(array.type, null, arrayspec, array)
 
-        super.visit(refLiteral)
+        super.visit(array)
 
-        when(refLiteral.type) {
-            in StringDatatypes -> {
-                if(refLiteral.heapId==null)
-                    throw FatalAstException("string should have been moved to heap at ${refLiteral.position}")
-            }
-            in ArrayDatatypes -> {
-                if(refLiteral.heapId==null)
-                    throw FatalAstException("array should have been moved to heap at ${refLiteral.position}")
-            }
-            else -> {}
-        }
+        if(array.heapId==null && array.parent !is IFunctionCall)
+            throw FatalAstException("array should have been moved to heap at ${array.position}")
+    }
+
+    override fun visit(string: StringLiteralValue) {
+        checkValueTypeAndRangeString(string.type, string)
+        super.visit(string)
+        if(string.heapId==null)
+            throw FatalAstException("string should have been moved to heap at ${string.position}")
     }
 
     override fun visit(expr: PrefixExpression) {
         if(expr.operator=="-") {
-            val dt = expr.inferType(program)
+            val dt = expr.inferType(program).typeOrElse(DataType.STRUCT)
             if (dt != DataType.BYTE && dt != DataType.WORD && dt != DataType.FLOAT) {
                 checkResult.add(ExpressionError("can only take negative of a signed number type", expr.position))
             }
@@ -694,8 +717,13 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(expr: BinaryExpression) {
-        val leftDt = expr.left.inferType(program)
-        val rightDt = expr.right.inferType(program)
+        val leftIDt = expr.left.inferType(program)
+        val rightIDt = expr.right.inferType(program)
+        if(!leftIDt.isKnown || !rightIDt.isKnown) {
+            throw FatalAstException("can't determine datatype of both expression operands $expr")
+        }
+        val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
+        val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
 
         when(expr.operator){
             "/", "%" -> {
@@ -726,12 +754,20 @@ internal class AstChecker(private val program: Program,
                 if(leftDt !in IntegerDatatypes || rightDt !in IntegerDatatypes)
                     checkResult.add(ExpressionError("bitwise operator can only be used on integer operands", expr.right.position))
             }
+            "<<", ">>" -> {
+                // for now, bit-shifts can only shift by a constant number
+                val constRight = expr.right.constValue(program)
+                if(constRight==null)
+                    checkResult.add(ExpressionError("bit-shift can only be done by a constant number (for now)", expr.right.position))
+            }
         }
 
         if(leftDt !in NumericDatatypes)
             checkResult.add(ExpressionError("left operand is not numeric", expr.left.position))
         if(rightDt!in NumericDatatypes)
             checkResult.add(ExpressionError("right operand is not numeric", expr.right.position))
+        if(leftDt!=rightDt)
+            checkResult.add(ExpressionError("left and right operands aren't the same type", expr.left.position))
         super.visit(expr)
     }
 
@@ -748,8 +784,11 @@ internal class AstChecker(private val program: Program,
         super.visit(range)
         val from = range.from.constValue(program)
         val to = range.to.constValue(program)
-        val stepLv = range.step.constValue(program) ?: NumericLiteralValue(DataType.UBYTE, 1, range.position)
-        if (stepLv.type !in IntegerDatatypes || stepLv.number.toInt() == 0) {
+        val stepLv = range.step.constValue(program)
+        if(stepLv==null) {
+            err("range step must be a constant integer")
+            return
+        } else if (stepLv.type !in IntegerDatatypes || stepLv.number.toInt() == 0) {
             err("range step must be an integer != 0")
             return
         }
@@ -792,6 +831,13 @@ internal class AstChecker(private val program: Program,
             else
                 printWarning("result values of subroutine call are discarded", functionCallStatement.position)
         }
+
+        if(functionCallStatement.target.nameInSource.last() in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) {
+            // in-place modification, can't be done on literals
+            if(functionCallStatement.arglist.any { it !is IdentifierReference && it !is RegisterExpr && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) {
+                checkResult.add(ExpressionError("can't use that as argument to a in-place modifying function", functionCallStatement.position))
+            }
+        }
         super.visit(functionCallStatement)
     }
 
@@ -805,33 +851,48 @@ internal class AstChecker(private val program: Program,
             if(args.size!=func.parameters.size)
                 checkResult.add(SyntaxError("invalid number of arguments", position))
             else {
+                val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
                 for (arg in args.withIndex().zip(func.parameters)) {
                     val argDt=arg.first.value.inferType(program)
-                    if(argDt!=null && !(argDt isAssignableTo arg.second.possibleDatatypes)) {
+                    if (argDt.isKnown
+                            && !(argDt.typeOrElse(DataType.STRUCT) isAssignableTo arg.second.possibleDatatypes)
+                            && (argDt.typeOrElse(DataType.STRUCT) != DataType.UWORD || arg.second.possibleDatatypes.intersect(paramTypesForAddressOf).isEmpty())) {
                         checkResult.add(ExpressionError("builtin function '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position))
                     }
                 }
                 if(target.name=="swap") {
-                    // swap() is a bit weird because this one is translated into a sequence of bytecodes, instead of being an actual function call
-                    val dt1 = args[0].inferType(program)!!
-                    val dt2 = args[1].inferType(program)!!
+                    // swap() is a bit weird because this one is translated into a operations directly, instead of being a function call
+                    val dt1 = args[0].inferType(program)
+                    val dt2 = args[1].inferType(program)
                     if (dt1 != dt2)
                         checkResult.add(ExpressionError("swap requires 2 args of identical type", position))
                     else if (args[0].constValue(program) != null || args[1].constValue(program) != null)
                         checkResult.add(ExpressionError("swap requires 2 variables, not constant value(s)", position))
                     else if(args[0] isSameAs args[1])
                         checkResult.add(ExpressionError("swap should have 2 different args", position))
-                    else if(dt1 !in NumericDatatypes)
+                    else if(dt1.typeOrElse(DataType.STRUCT) !in NumericDatatypes)
                         checkResult.add(ExpressionError("swap requires args of numerical type", position))
                 }
+                else if(target.name=="all" || target.name=="any") {
+                    if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype in StringDatatypes) {
+                        checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
+                    }
+                    if(args[0].inferType(program).typeOrElse(DataType.STR) in StringDatatypes) {
+                        checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
+                    }
+                }
             }
         } else if(target is Subroutine) {
             if(args.size!=target.parameters.size)
                 checkResult.add(SyntaxError("invalid number of arguments", position))
             else {
                 for (arg in args.withIndex().zip(target.parameters)) {
-                    val argDt = arg.first.value.inferType(program)
-                    if(argDt!=null && !(argDt isAssignableTo arg.second.type)) {
+                    val argIDt = arg.first.value.inferType(program)
+                    if(!argIDt.isKnown) {
+                        throw FatalAstException("can't determine arg dt ${arg.first.value}")
+                    }
+                    val argDt=argIDt.typeOrElse(DataType.STRUCT)
+                    if(!(argDt isAssignableTo arg.second.type)) {
                         // for asm subroutines having STR param it's okay to provide a UWORD (address value)
                         if(!(target.isAsmSubroutine && arg.second.type in StringDatatypes && argDt == DataType.UWORD))
                             checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position))
@@ -866,7 +927,7 @@ internal class AstChecker(private val program: Program,
             val targetName = postIncrDecr.target.identifier!!.nameInSource
             val target = program.namespace.lookup(targetName, postIncrDecr)
             if(target==null) {
-                checkResult.add(SyntaxError("undefined symbol: ${targetName.joinToString(".")}", postIncrDecr.position))
+                checkResult.add(UndefinedSymbolError(postIncrDecr.target.identifier!!))
             } else {
                 if(target !is VarDecl || target.type== VarDeclType.CONST) {
                     checkResult.add(SyntaxError("can only increment or decrement a variable", postIncrDecr.position))
@@ -877,7 +938,7 @@ internal class AstChecker(private val program: Program,
         } else if(postIncrDecr.target.arrayindexed != null) {
             val target = postIncrDecr.target.arrayindexed?.identifier?.targetStatement(program.namespace)
             if(target==null) {
-                checkResult.add(SyntaxError("undefined symbol", postIncrDecr.position))
+                checkResult.add(NameError("undefined symbol", postIncrDecr.position))
             }
             else {
                 val dt = (target as VarDecl).datatype
@@ -902,18 +963,20 @@ internal class AstChecker(private val program: Program,
                 if(index!=null && (index<0 || index>=arraysize))
                     checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position))
             } else if(target.datatype in StringDatatypes) {
-                // check string lengths
-                val heapId = (target.value as ReferenceLiteralValue).heapId!!
-                val stringLen = program.heap.get(heapId).str!!.length
-                val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
-                if(index!=null && (index<0 || index>=stringLen))
-                    checkResult.add(ExpressionError("index out of bounds", arrayIndexedExpression.arrayspec.position))
+                if(target.value is StringLiteralValue) {
+                    // check string lengths for non-memory mapped strings
+                    val heapId = (target.value as StringLiteralValue).heapId!!
+                    val stringLen = program.heap.get(heapId).str!!.length
+                    val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
+                    if (index != null && (index < 0 || index >= stringLen))
+                        checkResult.add(ExpressionError("index out of bounds", arrayIndexedExpression.arrayspec.position))
+                }
             }
         } else
             checkResult.add(SyntaxError("indexing requires a variable to act upon", arrayIndexedExpression.position))
 
         // check index value 0..255
-        val dtx = arrayIndexedExpression.arrayspec.index.inferType(program)
+        val dtx = arrayIndexedExpression.arrayspec.index.inferType(program).typeOrElse(DataType.STRUCT)
         if(dtx!= DataType.UBYTE && dtx!= DataType.BYTE)
             checkResult.add(SyntaxError("array indexing is limited to byte size 0..255", arrayIndexedExpression.position))
 
@@ -921,7 +984,7 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(whenStatement: WhenStatement) {
-        val conditionType = whenStatement.condition.inferType(program)
+        val conditionType = whenStatement.condition.inferType(program).typeOrElse(DataType.STRUCT)
         if(conditionType !in IntegerDatatypes)
             checkResult.add(SyntaxError("when condition must be an integer value", whenStatement.position))
         val choiceValues = whenStatement.choiceValues(program)
@@ -930,6 +993,9 @@ internal class AstChecker(private val program: Program,
         tally.filter { it.value>1 }.forEach {
             checkResult.add(SyntaxError("choice value occurs multiple times", it.key.position))
         }
+        if(whenStatement.choices.isEmpty())
+            checkResult.add(SyntaxError("empty when statement", whenStatement.position))
+
         super.visit(whenStatement)
     }
 
@@ -937,12 +1003,14 @@ internal class AstChecker(private val program: Program,
         val whenStmt = whenChoice.parent as WhenStatement
         if(whenChoice.values!=null) {
             val conditionType = whenStmt.condition.inferType(program)
-            val constvalues = whenChoice.values.map { it.constValue(program) }
+            if(!conditionType.isKnown)
+                throw FatalAstException("can't determine when choice datatype $whenChoice")
+            val constvalues = whenChoice.values!!.map { it.constValue(program) }
             for(constvalue in constvalues) {
                 when {
                     constvalue == null -> checkResult.add(SyntaxError("choice value must be a constant", whenChoice.position))
                     constvalue.type !in IntegerDatatypes -> checkResult.add(SyntaxError("choice value must be a byte or word", whenChoice.position))
-                    constvalue.type != conditionType -> checkResult.add(SyntaxError("choice value datatype differs from condition value", whenChoice.position))
+                    constvalue.type != conditionType.typeOrElse(DataType.STRUCT) -> checkResult.add(SyntaxError("choice value datatype differs from condition value", whenChoice.position))
                 }
             }
         } else {
@@ -978,26 +1046,37 @@ internal class AstChecker(private val program: Program,
         return null
     }
 
-    private fun checkValueTypeAndRange(targetDt: DataType, struct: StructDecl?,
-                                       arrayspec: ArrayIndex, value: ReferenceLiteralValue, heap: HeapValues) : Boolean {
+    private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteralValue) : Boolean {
+        fun err(msg: String): Boolean {
+            checkResult.add(ExpressionError(msg, value.position))
+            return false
+        }
+        return when (targetDt) {
+            in StringDatatypes -> {
+                return if (value.value.length > 255)
+                    err("string length must be 0-255")
+                else
+                    true
+            }
+            else -> false
+        }
+    }
+
+    private fun checkValueTypeAndRangeArray(targetDt: DataType, struct: StructDecl?,
+                                            arrayspec: ArrayIndex, value: ArrayLiteralValue) : Boolean {
         fun err(msg: String) : Boolean {
             checkResult.add(ExpressionError(msg, value.position))
             return false
         }
         when (targetDt) {
-            in StringDatatypes -> {
-                if(!value.isString)
-                    return err("string value expected")
-                if (value.str!!.length > 255)
-                    return err("string length must be 0-255")
-            }
+            in StringDatatypes -> return err("string value expected")
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
                 // value may be either a single byte, or a byte arraysize (of all constant values), or a range
                 if(value.type==targetDt) {
                     if(!checkArrayValues(value, targetDt))
                         return false
                     val arraySpecSize = arrayspec.size()
-                    val arraySize = value.array?.size ?: heap.get(value.heapId!!).arraysize
+                    val arraySize = value.value.size
                     if(arraySpecSize!=null && arraySpecSize>0) {
                         if(arraySpecSize<1 || arraySpecSize>256)
                             return err("byte array length must be 1-256")
@@ -1019,7 +1098,7 @@ internal class AstChecker(private val program: Program,
                     if(!checkArrayValues(value, targetDt))
                         return false
                     val arraySpecSize = arrayspec.size()
-                    val arraySize = value.array?.size ?: heap.get(value.heapId!!).arraysize
+                    val arraySize = value.value.size
                     if(arraySpecSize!=null && arraySpecSize>0) {
                         if(arraySpecSize<1 || arraySpecSize>128)
                             return err("word array length must be 1-128")
@@ -1040,7 +1119,7 @@ internal class AstChecker(private val program: Program,
                 if(value.type==targetDt) {
                     if(!checkArrayValues(value, targetDt))
                         return false
-                    val arraySize = value.array?.size ?: heap.get(value.heapId!!).doubleArray!!.size
+                    val arraySize = value.value.size
                     val arraySpecSize = arrayspec.size()
                     if(arraySpecSize!=null && arraySpecSize>0) {
                         if(arraySpecSize < 1 || arraySpecSize>51)
@@ -1055,10 +1134,7 @@ internal class AstChecker(private val program: Program,
                         return err("invalid float array size, must be 1-51")
 
                     // check if the floating point values are all within range
-                    val doubles = if(value.array!=null)
-                        value.array.map {it.constValue(program)?.number!!.toDouble()}.toDoubleArray()
-                    else
-                        heap.get(value.heapId!!).doubleArray!!
+                    val doubles = value.value.map {it.constValue(program)?.number!!.toDouble()}.toDoubleArray()
                     if(doubles.any { it < FLOAT_MAX_NEGATIVE || it> FLOAT_MAX_POSITIVE })
                         return err("floating point value overflow")
                     return true
@@ -1067,12 +1143,12 @@ internal class AstChecker(private val program: Program,
             }
             DataType.STRUCT -> {
                 if(value.type in ArrayDatatypes) {
-                    if(value.array!!.size != struct!!.numberOfElements)
+                    if(value.value.size != struct!!.numberOfElements)
                         return err("number of values is not the same as the number of members in the struct")
-                    for(elt in value.array.zip(struct.statements)) {
+                    for(elt in value.value.zip(struct.statements)) {
                         val vardecl = elt.second as VarDecl
-                        val valuetype = elt.first.inferType(program)!!
-                        if (!(valuetype isAssignableTo vardecl.datatype)) {
+                        val valuetype = elt.first.inferType(program)
+                        if (!valuetype.isKnown || !(valuetype.typeOrElse(DataType.STRUCT) isAssignableTo vardecl.datatype)) {
                             checkResult.add(ExpressionError("invalid struct member init value type $valuetype, expected ${vardecl.datatype}", elt.first.position))
                             return false
                         }
@@ -1083,7 +1159,6 @@ internal class AstChecker(private val program: Program,
             }
             else -> return false
         }
-        return true
     }
 
     private fun checkValueTypeAndRange(targetDt: DataType, value: NumericLiteralValue) : Boolean {
@@ -1130,10 +1205,10 @@ internal class AstChecker(private val program: Program,
         return true
     }
 
-    private fun checkArrayValues(value: ReferenceLiteralValue, type: DataType): Boolean {
-        if(value.isArray && value.heapId==null) {
+    private fun checkArrayValues(value: ArrayLiteralValue, type: DataType): Boolean {
+        if(value.heapId==null) {
             // hmm weird, array literal that hasn't been moved to the heap yet?
-            val array = value.array!!.map { it.constValue(program)!! }
+            val array = value.value.mapNotNull { it.constValue(program) }
             val correct: Boolean
             when(type) {
                 DataType.ARRAY_UB -> {

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

@@ -7,10 +7,12 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+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>()
@@ -64,6 +66,9 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             // 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.name}'", 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) {
@@ -98,17 +103,28 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
     }
 
     override fun visit(subroutine: Subroutine): Statement {
-        if(subroutine.name in BuiltinFunctions) {
+        if(subroutine.name in AssemblyProgram.opcodeNames) {
+            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${subroutine.name}'", 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 {
-            if (subroutine.parameters.any { it.name in BuiltinFunctions })
-                checkResult.add(NameError("builtin function name cannot be used as parameter", subroutine.position))
+            // 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()
@@ -127,24 +143,30 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             // 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.asmAddress==null) {
                 if(subroutine.asmParameterRegisters.isEmpty()) {
                     subroutine.parameters
                             .filter { it.name !in namesInSub }
                             .forEach {
-                                val vardecl = VarDecl(VarDeclType.VAR, it.type, ZeropageWish.DONTCARE, null, it.name, null, null,
+                                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)
                             }
                 }
             }
+
+            if(subroutine.isAsmSubroutine && subroutine.statements.any{it !is InlineAssembly}) {
+                checkResult.add(SyntaxError("asmsub can only contain inline assembly (%asm)", subroutine.position))
+            }
         }
         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.name}'", label.position))
+
         if(label.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
             checkResult.add(NameError("builtin function cannot be redefined", label.position))
@@ -162,34 +184,23 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         // 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 if(forLoop.loopVar!=null) {
-            val varName = forLoop.loopVar.nameInSource.last()
-            if(forLoop.decltype!=null) {
-                val existing = if(forLoop.body.containsNoCodeNorVars()) 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, forLoop.zeropage, null, varName, null, null,
-                            isArray = false, autogeneratedDontRemove = true, position = 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.containsNoCodeNorVars()) 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, ZeropageWish.PREFER_ZEROPAGE, null, ForLoop.iteratorLoopcounterVarname, null, null,
-                            isArray = false, autogeneratedDontRemove = true, position = forLoop.loopVar.position)
-                    vardecl.linkParents(forLoop.body)
-                    forLoop.body.statements.add(0, vardecl)
-                    forLoop.loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
+        } else {
+            val loopVar = forLoop.loopVar
+            if (loopVar != null) {
+                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'
+                    }
                 }
             }
         }
@@ -211,8 +222,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             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
+                newValue = lval.cast(subroutine.returntypes.single())
             } else {
                 newValue = returnStmt.value!!
             }
@@ -222,30 +232,85 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         return super.visit(returnStmt)
     }
 
-    override fun visit(refLiteral: ReferenceLiteralValue): Expression {
-        if(refLiteral.parent !is VarDecl) {
-            return makeIdentifierFromRefLv(refLiteral)
+    override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
+        val array = super.visit(arrayLiteral)
+        if(array is ArrayLiteralValue) {
+            val vardecl = array.parent as? VarDecl
+            return if (vardecl!=null) {
+                fixupArrayDatatype(array, vardecl, program)
+            } else if(array.heapId!=null) {
+                // 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(array.value)
+                val litval2 = array.cast(datatype)!!
+                litval2.parent = array.parent
+                // finally, replace the literal array by a identifier reference.
+                makeIdentifierFromRefLv(litval2)
+            } else
+                array
         }
-        return super.visit(refLiteral)
+        return array
     }
 
-    private fun makeIdentifierFromRefLv(refLiteral: ReferenceLiteralValue): IdentifierReference {
+    override fun visit(stringLiteral: StringLiteralValue): Expression {
+        val string = super.visit(stringLiteral)
+        if(string is StringLiteralValue) {
+            val vardecl = string.parent as? VarDecl
+            // intern the string; move it into the heap
+            if (string.value.length !in 1..255)
+                checkResult.add(ExpressionError("string literal length must be between 1 and 255", string.position))
+            else {
+                string.addToHeap(program.heap)
+            }
+            return if (vardecl != null)
+                string
+            else
+                makeIdentifierFromRefLv(string)  // replace the literal string by a identifier reference.
+        }
+        return string
+    }
+
+    private fun determineArrayDt(array: Array<Expression>): DataType {
+        val datatypesInArray = array.map { it.inferType(program) }
+        if(datatypesInArray.isEmpty() || datatypesInArray.any { !it.isKnown })
+            throw IllegalArgumentException("can't determine type of empty array")
+        val dts = datatypesInArray.map { it.typeOrElse(DataType.STRUCT) }
+        return when {
+            DataType.FLOAT in dts -> DataType.ARRAY_F
+            DataType.WORD in dts -> DataType.ARRAY_W
+            DataType.UWORD in dts -> DataType.ARRAY_UW
+            DataType.BYTE in dts -> DataType.ARRAY_B
+            DataType.UBYTE in dts -> DataType.ARRAY_UB
+            else -> throw IllegalArgumentException("can't determine type of array")
+        }
+    }
+
+    private fun makeIdentifierFromRefLv(array: ArrayLiteralValue): 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
-        refLiteral.addToHeap(program.heap)
-        val variable = VarDecl.createAuto(refLiteral, program.heap)
-        addVarDecl(refLiteral.definingScope(), variable)
-        // replace the reference literal by a identifier reference
-        val identifier = IdentifierReference(listOf(variable.name), variable.position)
-        identifier.parent = refLiteral.parent
-        return identifier
+        // note: if the var references the same literal value, it is not yet de-duplicated here.
+        array.addToHeap(program.heap)
+        val scope = array.definingScope()
+        val variable = VarDecl.createAuto(array)
+        return replaceWithIdentifier(variable, scope, array.parent)
     }
 
-    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)
+    private fun makeIdentifierFromRefLv(string: StringLiteralValue): 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.
+        string.addToHeap(program.heap)
+        val scope = string.definingScope()
+        val variable = VarDecl.createAuto(string)
+        return replaceWithIdentifier(variable, scope, string.parent)
+    }
+
+    private fun replaceWithIdentifier(variable: VarDecl, scope: INameScope, parent: Node): IdentifierReference {
+        val variable1 = addVarDecl(scope, variable)
+        // replace the reference literal by a identifier reference
+        val identifier = IdentifierReference(listOf(variable1.name), variable1.position)
+        identifier.parent = parent
+        return identifier
     }
 
     override fun visit(structDecl: StructDecl): Statement {
@@ -260,42 +325,110 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     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)
+            expr.left is StringLiteralValue ->
+                processBinaryExprWithString(expr.left as StringLiteralValue, expr.right, expr)
+            expr.right is StringLiteralValue ->
+                processBinaryExprWithString(expr.right as StringLiteralValue, 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)
-                }
+    private fun processBinaryExprWithString(string: StringLiteralValue, operand: Expression, expr: BinaryExpression): Expression {
+        val constvalue = operand.constValue(program)
+        if(constvalue!=null) {
+            if (expr.operator == "*") {
+                // repeat a string a number of times
+                val idt = string.inferType(program)
+                return StringLiteralValue(idt.typeOrElse(DataType.STR),
+                        string.value.repeat(constvalue.number.toInt()), null, expr.position)
             }
         }
+        if(expr.operator == "+" && operand is StringLiteralValue) {
+            // concatenate two strings
+            val idt = string.inferType(program)
+            return StringLiteralValue(idt.typeOrElse(DataType.STR),
+                    "${string.value}${operand.value}", null, expr.position)
+        }
         return expr
     }
 
-    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
+    private fun addVarDecl(scope: INameScope, variable: VarDecl): VarDecl {
         if(scope !in vardeclsToAdd)
             vardeclsToAdd[scope] = mutableListOf()
         val declList = vardeclsToAdd.getValue(scope)
-        if(declList.all{it.name!=variable.name})
+        val existing = declList.singleOrNull { it.name==variable.name }
+        return if(existing!=null) {
+            existing
+        } else {
             declList.add(variable)
+            variable
+        }
     }
 
 }
+
+internal fun fixupArrayDatatype(array: ArrayLiteralValue, program: Program): ArrayLiteralValue {
+    val dts = array.value.map {it.inferType(program).typeOrElse(DataType.STRUCT)}.toSet()
+    if(dts.any { it !in NumericDatatypes }) {
+        return array
+    }
+    val dt = when {
+        DataType.FLOAT in dts -> DataType.ARRAY_F
+        DataType.WORD in dts -> DataType.ARRAY_W
+        DataType.UWORD in dts -> DataType.ARRAY_UW
+        DataType.BYTE in dts -> DataType.ARRAY_B
+        else -> DataType.ARRAY_UB
+    }
+    if(dt==array.type)
+        return array
+
+    // convert values and array type
+    val elementType = ArrayElementTypes.getValue(dt)
+    val values = array.value.map { (it as NumericLiteralValue).cast(elementType) as Expression}.toTypedArray()
+    val array2 = ArrayLiteralValue(dt, values, array.heapId, array.position)
+    array2.linkParents(array.parent)
+    return array2
+}
+
+internal fun fixupArrayDatatype(array: ArrayLiteralValue, vardecl: VarDecl, program: Program): ArrayLiteralValue {
+    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 =
+                    try {
+                        val result = array.cast(vardecl.datatype)
+                        if(result==null) {
+                            val constElements = array.value.mapNotNull { it.constValue(program) }
+                            val elementDts = constElements.map { it.type }
+                            if(DataType.FLOAT in elementDts) {
+                                array.cast(DataType.ARRAY_F) ?: ArrayLiteralValue(DataType.ARRAY_F, array.value, array.heapId, array.position)
+                            } else {
+                                val numbers = constElements.map { it.number.toInt() }
+                                val minValue = numbers.min()!!
+                                val maxValue = numbers.max()!!
+                                if (minValue >= 0) {
+                                    // only positive values, so uword or ubyte
+                                    val dt = if(maxValue<256) DataType.ARRAY_UB else DataType.ARRAY_UW
+                                    array.cast(dt) ?: ArrayLiteralValue(dt, array.value, array.heapId, array.position)
+                                } else {
+                                    // negative value present, so word or byte
+                                    val dt = if(minValue >= -128 && maxValue<=127) DataType.ARRAY_B else DataType.ARRAY_W
+                                    array.cast(dt) ?: ArrayLiteralValue(dt, array.value, array.heapId, array.position)
+                                }
+                            }
+                        }
+                        else result
+                    } catch(x: ExpressionError) {
+                        // couldn't cast permanently.
+                        // instead, simply adjust the array type and trust the AstChecker to report the exact error
+                        ArrayLiteralValue(vardecl.datatype, array.value, array.heapId, array.position)
+                    }
+            vardecl.value = litval2
+            litval2.linkParents(vardecl)
+            litval2.addToHeap(program.heap)
+            return litval2
+        }
+    }
+    return array
+}

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

@@ -2,6 +2,7 @@ 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.*
 
@@ -11,7 +12,7 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(module: Module) {
-        module.statements = module.statements.asSequence().map { it.accept(this) }.toMutableList()
+        module.statements = module.statements.map { it.accept(this) }.toMutableList()
     }
 
     fun visit(expr: PrefixExpression): Expression {
@@ -30,7 +31,7 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(block: Block): Statement {
-        block.statements = block.statements.asSequence().map { it.accept(this) }.toMutableList()
+        block.statements = block.statements.map { it.accept(this) }.toMutableList()
         return block
     }
 
@@ -41,7 +42,7 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(subroutine: Subroutine): Statement {
-        subroutine.statements = subroutine.statements.asSequence().map { it.accept(this) }.toMutableList()
+        subroutine.statements = subroutine.statements.map { it.accept(this) }.toMutableList()
         return subroutine
     }
 
@@ -49,6 +50,8 @@ interface IAstModifyingVisitor {
         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
     }
@@ -57,6 +60,8 @@ interface IAstModifyingVisitor {
         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
     }
@@ -105,14 +110,16 @@ interface IAstModifyingVisitor {
         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
-            }
+    fun visit(stringLiteral: StringLiteralValue): Expression {
+        return stringLiteral
+    }
+
+    fun visit(arrayLiteral: ArrayLiteralValue): Expression {
+        for(av in arrayLiteral.value.withIndex()) {
+            val newvalue = av.value.accept(this)
+            arrayLiteral.value[av.index] = newvalue
         }
-        return refLiteral
+        return arrayLiteral
     }
 
     fun visit(assignment: Assignment): Statement {
@@ -135,7 +142,12 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(forLoop: ForLoop): Statement {
-        forLoop.loopVar?.accept(this)
+        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
@@ -158,21 +170,28 @@ interface IAstModifyingVisitor {
         return returnStmt
     }
 
-    fun visit(arrayIndexedExpression: ArrayIndexedExpression): Expression {
-        arrayIndexedExpression.identifier.accept(this)
+    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 {
-        assignTarget.arrayindexed?.accept(this)
-        assignTarget.identifier?.accept(this)
+        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.asSequence().map { it.accept(this) }.toMutableList()
+        scope.statements = scope.statements.map { it.accept(this) }.toMutableList()
         return scope
     }
 
@@ -191,7 +210,11 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(addressOf: AddressOf): Expression {
-        addressOf.identifier.accept(this)
+        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
     }
 
@@ -212,14 +235,20 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(whenStatement: WhenStatement): Statement {
-        whenStatement.condition.accept(this)
+        whenStatement.condition = whenStatement.condition.accept(this)
         whenStatement.choices.forEach { it.accept(this) }
         return whenStatement
     }
 
     fun visit(whenChoice: WhenChoice) {
-        whenChoice.values?.forEach { it.accept(this) }
-        whenChoice.statements.accept(this)
+        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 {

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

@@ -79,8 +79,11 @@ interface IAstVisitor {
     fun visit(numLiteral: NumericLiteralValue) {
     }
 
-    fun visit(refLiteral: ReferenceLiteralValue) {
-        refLiteral.array?.let { it.forEach { v->v.accept(this) }}
+    fun visit(string: StringLiteralValue) {
+    }
+
+    fun visit(array: ArrayLiteralValue) {
+        array.value.forEach { v->v.accept(this) }
     }
 
     fun visit(assignment: Assignment) {

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

@@ -4,13 +4,12 @@ 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.mangledStructMemberName
 import prog8.ast.statements.*
-import prog8.functions.BuiltinFunctions
 
 
-fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
+private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, program: Program): List<Assignment> {
     val identifier = structAssignment.target.identifier!!
     val identifierName = identifier.nameInSource.single()
     val targetVar = identifier.targetVarDecl(program.namespace)!!
@@ -61,13 +60,13 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
     // - 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")
 
+    private val addReturns = mutableListOf<Pair<INameScope, Int>>()
+
     override fun visit(module: Module) {
+        addReturns.clear()
         super.visit(module)
 
         val (blocks, other) = module.statements.partition { it is Block }
@@ -95,6 +94,13 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
         val directives = module.statements.filter {it is Directive && it.directive in directivesToMove}
         module.statements.removeAll(directives)
         module.statements.addAll(0, directives)
+
+        for(pos in addReturns) {
+            println(pos)
+            val returnStmt = Return(null, pos.first.position)
+            returnStmt.linkParents(pos.first as Node)
+            pos.first.statements.add(pos.second, returnStmt)
+        }
     }
 
     override fun visit(block: Block): Statement {
@@ -164,6 +170,19 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
     override fun visit(subroutine: Subroutine): Statement {
         super.visit(subroutine)
 
+        val scope = subroutine.definingScope()
+        if(scope is Subroutine) {
+            for(stmt in scope.statements.withIndex()) {
+                if(stmt.index>0 && stmt.value===subroutine) {
+                    val precedingStmt = scope.statements[stmt.index-1]
+                    if(precedingStmt !is Jump && precedingStmt !is Subroutine) {
+                        // insert a return statement before a nested subroutine, to avoid falling trough inside the subroutine
+                        addReturns.add(Pair(scope, stmt.index))
+                    }
+                }
+            }
+        }
+
         val varDecls = subroutine.statements.filterIsInstance<VarDecl>()
         subroutine.statements.removeAll(varDecls)
         subroutine.statements.addAll(0, varDecls)
@@ -186,61 +205,34 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
         return subroutine
     }
 
-    override fun visit(expr: BinaryExpression): Expression {
-        val leftDt = expr.left.inferType(program)
-        val rightDt = expr.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) = expr.commonDatatype(leftDt, rightDt, expr.left, expr.right)
-            if(toFix!=null) {
-                when {
-                    toFix===expr.left -> {
-                        expr.left = TypecastExpression(expr.left, commonDt, true, expr.left.position)
-                        expr.left.linkParents(expr)
-                    }
-                    toFix===expr.right -> {
-                        expr.right = TypecastExpression(expr.right, commonDt, true, expr.right.position)
-                        expr.right.linkParents(expr)
-                    }
-                    else -> throw FatalAstException("confused binary expression side")
-                }
-            }
-        }
-        return super.visit(expr)
-    }
-
     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)
+        val valueItype = assg.value.inferType(program)
+        val targetItype = assg.target.inferType(program, assg)
+
+        if(targetItype.isKnown && valueItype.isKnown) {
+            val targettype = targetItype.typeOrElse(DataType.STRUCT)
+            val valuetype = valueItype.typeOrElse(DataType.STRUCT)
+
+            // 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 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
             }
         }
 
@@ -264,155 +256,4 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
 
         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 -> {
-                // if(sub.name in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "memset", "memcopy", "memsetw", "swap"))
-                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(whenStatement: WhenStatement): Statement {
-        // make sure all choices are just for one single value
-        val choices = whenStatement.choices.toList()
-        for(choice in choices) {
-            if(choice.values==null || choice.values.size==1)
-                continue
-            for(v in choice.values) {
-                val newchoice=WhenChoice(listOf(v), choice.statements, choice.position)
-                newchoice.parent = choice.parent
-                whenStatement.choices.add(newchoice)
-            }
-            whenStatement.choices.remove(choice)
-        }
-
-        // sort the choices in low-to-high value order (nulls last)
-        whenStatement.choices
-                .sortWith(compareBy<WhenChoice, Int?>(nullsLast(), {it.values?.single()?.constValue(program)?.number?.toInt()}))
-        return super.visit(whenStatement)
-    }
-
-    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/TypecastsAdder.kt

@@ -0,0 +1,198 @@
+package prog8.ast.processing
+
+import prog8.ast.IFunctionCall
+import prog8.ast.INameScope
+import prog8.ast.Program
+import prog8.ast.base.DataType
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.printWarning
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.functions.BuiltinFunctions
+
+
+internal class TypecastsAdder(private val program: Program): IAstModifyingVisitor {
+    // Make 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)
+
+    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.isKnown && rightDt.isKnown && leftDt!=rightDt) {
+            // determine common datatype and add typecast as required to make left and right equal types
+            val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt.typeOrElse(DataType.STRUCT), rightDt.typeOrElse(DataType.STRUCT), 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 valueItype = assg.value.inferType(program)
+        val targetItype = assg.target.inferType(program, assg)
+
+        if(targetItype.isKnown && valueItype.isKnown) {
+            val targettype = targetItype.typeOrElse(DataType.STRUCT)
+            val valuetype = valueItype.typeOrElse(DataType.STRUCT)
+            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
+            }
+        }
+        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 argItype = arg.second.value.inferType(program)
+                    if(argItype.isKnown) {
+                        val argtype = argItype.typeOrElse(DataType.STRUCT)
+                        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 argItype = arg.second.value.inferType(program)
+                        if (argItype.isKnown) {
+                            val argtype = argItype.typeOrElse(DataType.STRUCT)
+                            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 -> throw FatalAstException("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.isKnown && dt.typeOrElse(DataType.UWORD)!=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.isKnown && dt.typeOrElse(DataType.UWORD)!=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.typeOrElse(memberDt) != memberDt)
+                TypecastExpression(it.second, memberDt, true, it.second.position)
+            else
+                it.second
+        }
+    }
+}

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

@@ -3,13 +3,16 @@ 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.CompilerException
+import prog8.functions.BuiltinFunctions
+import prog8.functions.FunctionSignature
 
 
-internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope, private val heap: HeapValues): IAstModifyingVisitor {
+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.
@@ -39,10 +42,10 @@ internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope
         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,
+            val array = ArrayLiteralValue(decl.datatype,
                     Array(arraysize) { NumericLiteralValue.optimalInteger(0, decl.position) },
                     null, decl.position)
-            array.addToHeap(heap)
+            array.addToHeap(program.heap)
             decl.value = array
         }
 
@@ -54,10 +57,8 @@ internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope
             addVarDecl(scope, decl.asDefaultValueDecl(null))
             val declvalue = decl.value!!
             val value =
-                    if(declvalue is NumericLiteralValue) {
-                        val converted = declvalue.cast(decl.datatype)
-                        converted ?: declvalue
-                    }
+                    if(declvalue is NumericLiteralValue)
+                        declvalue.cast(decl.datatype)
                     else
                         declvalue
             val identifierName = listOf(decl.name)    // this was: (scoped name) decl.scopedname.split(".")
@@ -73,20 +74,29 @@ internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope
     }
 
     override fun visit(functionCall: FunctionCall): Expression {
-        val targetStatement = functionCall.target.targetSubroutine(namespace)
+        var parentStatement: Node = functionCall
+        while(parentStatement !is Statement)
+            parentStatement = parentStatement.parent
+        val targetStatement = functionCall.target.targetSubroutine(program.namespace)
         if(targetStatement!=null) {
-            var node: Node = functionCall
-            while(node !is Statement)
-                node=node.parent
-            addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, node)
+            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(namespace)
-        if(targetStatement!=null)
+        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
     }
 
@@ -97,33 +107,45 @@ internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope
                 if(argparam.second is AddressOf)
                     continue
                 val idref = argparam.second as? IdentifierReference
-                val strvalue = argparam.second as? ReferenceLiteralValue
+                val strvalue = argparam.second as? StringLiteralValue
                 if(idref!=null) {
-                    val variable = idref.targetVarDecl(namespace)
+                    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, 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
-                    }
+                    // add a vardecl so that the autovar can be resolved in later lookups
+                    val variable = VarDecl.createAuto(strvalue)
+                    addVarDecl(strvalue.definingScope(), variable)
+                    // replace the argument with &autovar
+                    val autoHeapvarRef = IdentifierReference(listOf(variable.name), strvalue.position)
+                    val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
+                    pointerExpr.linkParents(arglist[argparam.first.index].parent)
+                    arglist[argparam.first.index] = pointerExpr
                 }
             }
         }
     }
 
+    private fun addAddressOfExprIfNeededForBuiltinFuncs(signature: FunctionSignature, args: MutableList<Expression>, parent: Statement) {
+        // val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
+        for(arg in args.withIndex().zip(signature.parameters)) {
+            val argvalue = arg.first.value
+            val argDt = argvalue.inferType(program)
+            if(argDt.typeOrElse(DataType.UBYTE) in PassByReferenceDatatypes && DataType.UWORD in arg.second.possibleDatatypes) {
+                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.linkParents(parent)
+            }
+        }
+    }
+
+
     private fun addVarDecl(scope: INameScope, variable: VarDecl) {
         if(scope !in vardeclsToAdd)
             vardeclsToAdd[scope] = mutableListOf()

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

@@ -5,7 +5,6 @@ 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 {
@@ -49,7 +48,7 @@ class BuiltinFunctionStatementPlaceholder(val name: String, override val positio
 }
 
 
-data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean?)
+data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean)
 
 
 class Block(override val name: String,
@@ -111,8 +110,6 @@ data class Label(val name: String, override val position: Position) : Statement(
     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() {
@@ -192,22 +189,28 @@ class VarDecl(val type: VarDeclType,
     override val expensiveToInline
             get() = value!=null && value !is NumericLiteralValue
 
+    // prefix for literal values that are turned into a variable on the heap
+
     companion object {
-        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")
+        private var autoHeapValueSequenceNumber = 0
 
-            val autoVarName = "$autoHeapValuePrefix${refLv.heapId}"
+        fun createAuto(string: StringLiteralValue): VarDecl {
+            if(string.heapId==null)
+                throw FatalAstException("can only create autovar for a string that has a heapid  $string")
+            val autoVarName = "auto_heap_value_${++autoHeapValueSequenceNumber}"
+            return VarDecl(VarDeclType.VAR, string.type, ZeropageWish.NOT_IN_ZEROPAGE, null, autoVarName, null, string,
+                        isArray = false, autogeneratedDontRemove = true, position = string.position)
+        }
 
-            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)
-            }
+        fun createAuto(array: ArrayLiteralValue): VarDecl {
+            if(array.heapId==null)
+                throw FatalAstException("can only create autovar for an array that has a heapid  $array")
+
+            val autoVarName = "auto_heap_value_${++autoHeapValueSequenceNumber}"
+            val declaredType = ArrayElementTypes.getValue(array.type)
+            val arraysize = ArrayIndex.forArray(array)
+            return VarDecl(VarDeclType.VAR, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, null, array,
+                    isArray = true, autogeneratedDontRemove = true, position = array.position)
         }
     }
 
@@ -292,15 +295,15 @@ class ArrayIndex(var index: Expression, override val position: Position) : Node
     }
 
     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 forArray(v: ArrayLiteralValue): ArrayIndex {
+            return ArrayIndex(NumericLiteralValue.optimalNumeric(v.value.size, v.position), v.position)
         }
     }
 
     fun accept(visitor: IAstModifyingVisitor) {
         index = index.accept(visitor)
     }
+
     fun accept(visitor: IAstVisitor) {
         index.accept(visitor)
     }
@@ -337,9 +340,9 @@ class VariableInitializationAssignment(target: AssignTarget, aug_op: String?, va
     : Assignment(target, aug_op, value, position)
 
 data class AssignTarget(val register: Register?,
-                        val identifier: IdentifierReference?,
-                        val arrayindexed: ArrayIndexedExpression?,
-                        var memoryAddress: DirectMemoryWrite?,
+                        var identifier: IdentifierReference?,
+                        var arrayindexed: ArrayIndexedExpression?,
+                        val memoryAddress: DirectMemoryWrite?,
                         override val position: Position) : Node {
     override lateinit var parent: Node
 
@@ -365,37 +368,35 @@ data class AssignTarget(val register: Register?,
         }
     }
 
-    fun inferType(program: Program, stmt: Statement): DataType? {
+    fun inferType(program: Program, stmt: Statement): InferredTypes.InferredType {
         if(register!=null)
-            return DataType.UBYTE
+            return InferredTypes.knownFor(DataType.UBYTE)
 
         if(identifier!=null) {
-            val symbol = program.namespace.lookup(identifier.nameInSource, stmt) ?: return null
-            if (symbol is VarDecl) return symbol.datatype
+            val symbol = program.namespace.lookup(identifier!!.nameInSource, stmt) ?: return InferredTypes.unknown()
+            if (symbol is VarDecl) return InferredTypes.knownFor(symbol.datatype)
         }
 
         if(arrayindexed!=null) {
-            val dt = arrayindexed.inferType(program)
-            if(dt!=null)
-                return dt
+            return arrayindexed!!.inferType(program)
         }
 
         if(memoryAddress!=null)
-            return DataType.UBYTE
+            return InferredTypes.knownFor(DataType.UBYTE)
 
-        return null
+        return InferredTypes.unknown()
     }
 
     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.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier!!.nameInSource
             this.arrayindexed!=null -> value is ArrayIndexedExpression &&
-                    value.identifier.nameInSource==arrayindexed.identifier.nameInSource &&
+                    value.identifier.nameInSource==arrayindexed!!.identifier.nameInSource &&
                     value.arrayspec.size()!=null &&
-                    arrayindexed.arrayspec.size()!=null &&
-                    value.arrayspec.size()==arrayindexed.arrayspec.size()
+                    arrayindexed!!.arrayspec.size()!=null &&
+                    value.arrayspec.size()==arrayindexed!!.arrayspec.size()
             else -> false
         }
     }
@@ -406,16 +407,16 @@ data class AssignTarget(val register: Register?,
         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
+            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)
+            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)
+            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
             }
         }
@@ -428,12 +429,12 @@ data class AssignTarget(val register: Register?,
         if(this.memoryAddress!=null)
             return false
         if(this.arrayindexed!=null) {
-            val targetStmt = this.arrayindexed.identifier.targetVarDecl(namespace)
+            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)
+            val targetStmt = this.identifier!!.targetVarDecl(namespace)
             if(targetStmt!=null)
                 return targetStmt.type!= VarDeclType.MEMORY
         }
@@ -518,15 +519,15 @@ class AnonymousScope(override var statements: MutableList<Statement>,
     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++
     }
 
-    companion object {
-        private var sequenceNumber = 1
-    }
-
     override fun linkParents(parent: Node) {
         this.parent = parent
         statements.forEach { it.linkParents(this) }
@@ -598,40 +599,6 @@ class Subroutine(override val name: String,
             .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,
@@ -682,9 +649,7 @@ class BranchStatement(var condition: BranchCondition,
 }
 
 class ForLoop(val loopRegister: Register?,
-              val decltype: DataType?,
-              val zeropage: ZeropageWish,
-              val loopVar: IdentifierReference?,
+              var loopVar: IdentifierReference?,
               var iterable: Expression,
               var body: AnonymousScope,
               override val position: Position) : Statement() {
@@ -693,7 +658,7 @@ class ForLoop(val loopRegister: Register?,
 
     override fun linkParents(parent: Node) {
         this.parent=parent
-        loopVar?.linkParents(if(decltype==null) this else body)
+        loopVar?.linkParents(this)
         iterable.linkParents(this)
         body.linkParents(this)
     }
@@ -704,10 +669,6 @@ class ForLoop(val loopRegister: Register?,
     override fun toString(): String {
         return "ForLoop(loopVar: $loopVar, loopReg: $loopRegister, iterable: $iterable, pos=$position)"
     }
-
-    companion object {
-        const val iteratorLoopcounterVarname = "prog8forloopcounter"
-    }
 }
 
 class WhileLoop(var condition: Expression,
@@ -742,8 +703,8 @@ class RepeatLoop(var body: AnonymousScope,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
 }
 
-class WhenStatement(val condition: Expression,
-                    val choices: MutableList<WhenChoice>,
+class WhenStatement(var condition: Expression,
+                    var choices: MutableList<WhenChoice>,
                     override val position: Position): Statement() {
     override lateinit var parent: Node
     override val expensiveToInline: Boolean = true
@@ -761,7 +722,7 @@ class WhenStatement(val condition: Expression,
             if(choice.values==null)
                 result.add(null to choice)
             else {
-                val values = choice.values.map { it.constValue(program)?.number?.toInt() }
+                val values = choice.values!!.map { it.constValue(program)?.number?.toInt() }
                 if(values.contains(null))
                     result.add(null to choice)
                 else
@@ -775,8 +736,8 @@ class WhenStatement(val condition: Expression,
     override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
 }
 
-class WhenChoice(val values: List<Expression>?,           // if null,  this is the 'else' part
-                 val statements: AnonymousScope,
+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
 
@@ -812,6 +773,8 @@ class StructDecl(override val name: String,
 
     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 {

compiler/src/prog8/compiler/Main.kt

@@ -1,10 +1,11 @@
 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.AsmGen
 import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.optimizer.constantFold
 import prog8.optimizer.optimizeStatements
 import prog8.optimizer.simplifyExpressions
@@ -12,19 +13,25 @@ import prog8.parser.ParsingFailedError
 import prog8.parser.importLibraryModule
 import prog8.parser.importModule
 import prog8.parser.moduleName
-import java.io.File
-import java.io.PrintStream
 import java.nio.file.Path
-import kotlin.system.exitProcess
 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,
-                   generateVmCode: Boolean, writeVmCode: Boolean,
-                   writeAssembly: Boolean): Pair<Program, String?> {
+                   optimize: 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
@@ -32,6 +39,8 @@ fun compileProgram(filepath: Path,
             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.")
@@ -60,12 +69,8 @@ fun compileProgram(filepath: Path,
             //println(" time2: $time2")
             val time3 = measureTimeMillis {
                 programAst.removeNopsFlattenAnonScopes()
-
-                // if you want to print the AST, do it before shuffling the statements around below
-                //printAst(programAst)
-
-
-                programAst.reorderStatements()     // reorder statements and add type casts, to please the compiler later
+                programAst.reorderStatements()
+                programAst.addTypecasts()
             }
             //println(" time3: $time3")
             val time4 = measureTimeMillis {
@@ -80,39 +85,28 @@ fun compileProgram(filepath: Path,
                 while (true) {
                     // keep optimizing expressions and statements until no more steps remain
                     val optsDone1 = programAst.simplifyExpressions()
-                    val optsDone2 = programAst.optimizeStatements(optimizeInlining)
+                    val optsDone2 = programAst.optimizeStatements()
                     if (optsDone1 + optsDone2 == 0)
                         break
                 }
             }
 
+            programAst.addTypecasts()
             programAst.removeNopsFlattenAnonScopes()
             programAst.checkValid(compilerOptions)          // check if final tree is valid
             programAst.checkRecursion()         // check if there are recursive subroutine calls
 
-            if(generateVmCode) {
-                // compile the syntax tree into stackvmProg form, and optimize that
-                val compiler = Compiler(programAst)
-                val intermediate = compiler.compile(compilerOptions)
-                if (optimize)
-                    intermediate.optimize()
+            // printAst(programAst)
 
-                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 = MachineDefinition.C64Zeropage(compilerOptions)
-                    intermediate.allocateZeropage(zeropage)
-                    val assembly = AsmGen(compilerOptions, intermediate, programAst.heap, zeropage).compileToAssembly(optimize)
-                    assembly.assemble(compilerOptions)
-                    programName = assembly.name
-                }
+            if(writeAssembly) {
+                // asm generation directly from the Ast, no need for intermediate code
+                val zeropage = MachineDefinition.C64Zeropage(compilerOptions)
+                programAst.anonscopeVarsCleanup()
+                val assembly = AsmGen(programAst, compilerOptions, zeropage).compileToAssembly(optimize)
+                assembly.assemble(compilerOptions)
+                programName = assembly.name
             }
+            success = true
         }
         println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
 
@@ -120,12 +114,10 @@ fun compileProgram(filepath: Path,
         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 *")
@@ -139,7 +131,7 @@ fun compileProgram(filepath: Path,
         System.out.flush()
         throw x
     }
-    return Pair(programAst, programName)
+    return CompilationResult(success, programAst, programName ?: "", importedFiles)
 }
 
 fun printAst(programAst: Program) {

compiler/src/prog8/compiler/Zeropage.kt

@@ -13,11 +13,14 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     val allowedDatatypes = NumericDatatypes
 
-    fun available() = free.size
+    fun available() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
 
     fun allocate(scopedname: String, datatype: DataType, position: Position?): Int {
         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) {
                     in ByteDatatypes -> 1

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/MachineDefinition.kt

@@ -42,14 +42,14 @@ object MachineDefinition {
         }
 
         override val exitProgramStrategy: ExitProgramStrategy = when (options.zeropage) {
-            ZeropageType.BASICSAFE -> ExitProgramStrategy.CLEAN_EXIT
+            ZeropageType.BASICSAFE, ZeropageType.DONTUSE -> 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.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)
@@ -84,11 +84,16 @@ object MachineDefinition {
                     ))
                 }
 
-                // 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))
+                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)

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

@@ -0,0 +1,48 @@
+package prog8.compiler.target.c64.codegen
+
+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>().associateBy { it.name }
+            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/codegen/AsmGen.kt

@@ -0,0 +1,879 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.antlr.escape
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.compiler.*
+import prog8.compiler.target.c64.AssemblyProgram
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.Petscii
+import prog8.functions.BuiltinFunctions
+import prog8.functions.FunctionSignature
+import java.io.File
+import java.math.RoundingMode
+import java.util.*
+import kotlin.math.absoluteValue
+
+
+internal class AssemblyError(msg: String) : RuntimeException(msg)
+
+
+internal class AsmGen(val program: Program,
+                      val options: CompilationOptions,
+                      val zeropage: Zeropage) {
+
+    private val assemblyLines = mutableListOf<String>()
+    private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
+    private val allocatedZeropageVariables = mutableMapOf<String, Pair<Int, DataType>>()
+    private val breakpointLabels = mutableListOf<String>()
+    private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this)
+    private val forloopsAsmGen = ForLoopsAsmGen(program, this)
+    private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
+    private val functioncallAsmGen = FunctionCallAsmGen(program, this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this)
+    private val expressionsAsmGen = ExpressionsAsmGen(program, this)
+    internal val loopEndLabels = Stack<String>()
+    internal val loopContinueLabels = Stack<String>()
+
+    internal fun compileToAssembly(optimize: Boolean): AssemblyProgram {
+        assemblyLines.clear()
+        loopEndLabels.clear()
+        loopContinueLabels.clear()
+
+        println("Generating assembly code... ")
+
+        header()
+        val allBlocks = program.allBlocks()
+        if(allBlocks.first().name != "main")
+            throw AssemblyError("first block should be 'main'")
+        for(b in program.allBlocks())
+            block2asm(b)
+        footer()
+
+        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 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")
+
+        program.actualLoadAddress = program.definedLoadAddress
+        if (program.actualLoadAddress == 0)   // fix load address
+            program.actualLoadAddress = if (options.launcher == LauncherType.BASIC)
+                MachineDefinition.BASIC_LOAD_ADDRESS else MachineDefinition.RAW_LOAD_ADDRESS
+
+        when {
+            options.launcher == LauncherType.BASIC -> {
+                if (program.actualLoadAddress != 0x0801)
+                    throw AssemblyError("BASIC output must have load address $0801")
+                out("; ---- basic program with sys call ----")
+                out("* = ${program.actualLoadAddress.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.actualLoadAddress.toHex()}\n")
+                out("  jsr  prog8_lib.init_system")
+            }
+            options.output == OutputType.RAW -> {
+                out("; ---- raw assembler program ----")
+                out("* = ${program.actualLoadAddress.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.allBlocks()) {
+            val initVarsSub = block.statements.singleOrNull { it is Subroutine && it.name == initvarsSubName }
+            if(initVarsSub!=null)
+                out("  jsr  ${block.name}.$initvarsSubName")
+        }
+
+        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("")
+    }
+
+    private fun footer() {
+        // the global list of all floating point constants for the whole program
+        out("; global float constants")
+        for (flt in globalFloatConsts) {
+            val mflpt5 = MachineDefinition.Mflpt5.fromNumber(flt.key)
+            val floatFill = makeFloatFill(mflpt5)
+            val floatvalue = flt.key
+            out("${flt.value}\t.byte  $floatFill  ; float $floatvalue")
+        }
+    }
+
+    private fun block2asm(block: Block) {
+        out("\n\n; ---- block: '${block.name}' ----")
+        out("${block.name}\t" + (if("force_output" in block.options()) ".block\n" else ".proc\n"))
+
+        if(block.address!=null) {
+            out(".cerror * > ${block.address.toHex()}, 'block address overlaps by ', *-${block.address.toHex()},' bytes'")
+            out("* = ${block.address.toHex()}")
+        }
+
+        outputSourceLine(block)
+        zeropagevars2asm(block.statements)
+        memdefs2asm(block.statements)
+        vardecls2asm(block.statements)
+        out("\n; subroutines in this block")
+
+        // first translate regular statements, and then put the subroutines at the end.
+        val (subroutine, stmts) = block.statements.partition { it is Subroutine }
+        stmts.forEach { translate(it) }
+        subroutine.forEach { translateSubroutine(it as Subroutine) }
+
+        out(if("force_output" in block.options()) "\n\t.bend\n" else "\n\t.pend\n")
+    }
+
+    private var generatedLabelSequenceNumber: Int = 0
+
+    internal fun makeLabel(postfix: String): String {
+        generatedLabelSequenceNumber++
+        return "_prog8_label_${generatedLabelSequenceNumber}_$postfix"
+    }
+
+    private fun outputSourceLine(node: Node) {
+        out(" ;\tsrc line: ${node.position.file}:${node.position.line}")
+    }
+
+    internal fun out(str: String, splitlines: Boolean = true) {
+        val fragment = (if(" | " in str) str.replace("|", "\n") else str).trim('\n')
+
+        if (splitlines) {
+            for (line in fragment.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(fragment)
+    }
+
+    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 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 zeropagevars2asm(statements: List<Statement>) {
+        out("; vars allocated on zeropage")
+        val variables = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.VAR }
+        for(variable in variables) {
+            // should NOT allocate subroutine parameters on the zero page
+            val fullName = variable.scopedname
+            val zpVar = allocatedZeropageVariables[fullName]
+            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.zeropage != ZeropageWish.NOT_IN_ZEROPAGE &&
+                        variable.datatype in zeropage.allowedDatatypes
+                        && variable.datatype != DataType.FLOAT
+                        && options.zeropage != ZeropageType.DONTUSE) {
+                    try {
+                        val address = zeropage.allocate(fullName, variable.datatype, null)
+                        out("${variable.name} = $address\t; auto zp ${variable.datatype}")
+                        // make sure we add the var to the set of zpvars for this block
+                        allocatedZeropageVariables[fullName] = Pair(address, variable.datatype)
+                    } catch (x: ZeropageDepletedError) {
+                        // leave it as it is.
+                    }
+                }
+            }
+        }
+    }
+
+    private fun vardecl2asm(decl: VarDecl) {
+        when (decl.datatype) {
+            DataType.UBYTE -> out("${decl.name}\t.byte  0")
+            DataType.BYTE -> out("${decl.name}\t.char  0")
+            DataType.UWORD -> out("${decl.name}\t.word  0")
+            DataType.WORD -> out("${decl.name}\t.sint  0")
+            DataType.FLOAT -> out("${decl.name}\t.byte  0,0,0,0,0  ; float")
+            DataType.STRUCT -> {}       // is flattened
+            DataType.STR, DataType.STR_S -> {
+                val string = (decl.value as StringLiteralValue).value
+                val encoded = encodeStr(string, decl.datatype)
+                outputStringvar(decl, encoded)
+            }
+            DataType.ARRAY_UB -> {
+                val data = makeArrayFillDataUnsigned(decl)
+                if (data.size <= 16)
+                    out("${decl.name}\t.byte  ${data.joinToString()}")
+                else {
+                    out(decl.name)
+                    for (chunk in data.chunked(16))
+                        out("  .byte  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_B -> {
+                val data = makeArrayFillDataSigned(decl)
+                if (data.size <= 16)
+                    out("${decl.name}\t.char  ${data.joinToString()}")
+                else {
+                    out(decl.name)
+                    for (chunk in data.chunked(16))
+                        out("  .char  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_UW -> {
+                val data = makeArrayFillDataUnsigned(decl)
+                if (data.size <= 16)
+                    out("${decl.name}\t.word  ${data.joinToString()}")
+                else {
+                    out(decl.name)
+                    for (chunk in data.chunked(16))
+                        out("  .word  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_W -> {
+                val data = makeArrayFillDataSigned(decl)
+                if (data.size <= 16)
+                    out("${decl.name}\t.sint  ${data.joinToString()}")
+                else {
+                    out(decl.name)
+                    for (chunk in data.chunked(16))
+                        out("  .sint  " + chunk.joinToString())
+                }
+            }
+            DataType.ARRAY_F -> {
+                val array = (decl.value as ArrayLiteralValue).value
+                val floatFills = array.map {
+                    val number = (it as NumericLiteralValue).number
+                    makeFloatFill(MachineDefinition.Mflpt5.fromNumber(number))
+                }
+                out(decl.name)
+                for (f in array.zip(floatFills))
+                    out("  .byte  ${f.second}  ; float ${f.first}")
+            }
+        }
+    }
+
+    private fun memdefs2asm(statements: List<Statement>) {
+        out("\n; memdefs and kernel subroutines")
+        val memvars = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.MEMORY || it.type==VarDeclType.CONST }
+        for(m in memvars) {
+            out("  ${m.name} = ${(m.value as NumericLiteralValue).number.toHex()}")
+        }
+        val asmSubs = statements.filterIsInstance<Subroutine>().filter { it.isAsmSubroutine }
+        for(sub in asmSubs) {
+            if(sub.asmAddress!=null) {
+                if(sub.statements.isNotEmpty())
+                    throw AssemblyError("kernel subroutine cannot have statements")
+                out("  ${sub.name} = ${sub.asmAddress.toHex()}")
+            }
+        }
+    }
+
+    private fun vardecls2asm(statements: List<Statement>) {
+        out("\n; non-zeropage variables")
+        val vars = statements.filterIsInstance<VarDecl>().filter { it.type==VarDeclType.VAR }
+
+        // first output the flattened struct member variables *in order*
+        // after that, the other variables sorted by their datatype
+
+        val (structMembers, normalVars) = vars.partition { it.struct!=null }
+        structMembers.forEach { vardecl2asm(it) }
+
+        // special treatment for string types: merge strings that are identical
+        val encodedstringVars = normalVars
+                .filter {it.datatype in StringDatatypes }
+                .map { it to encodeStr((it.value as StringLiteralValue).value, it.datatype) }
+                .groupBy({it.second}, {it.first})
+        for((encoded, variables) in encodedstringVars) {
+            variables.dropLast(1).forEach { out(it.name) }
+            val lastvar = variables.last()
+            outputStringvar(lastvar, encoded)
+        }
+
+        // non-string variables
+        normalVars.filter{ it.datatype !in StringDatatypes}.sortedBy { it.datatype }.forEach {
+            if(it.scopedname !in allocatedZeropageVariables)
+                vardecl2asm(it)
+        }
+    }
+
+    private fun outputStringvar(lastvar: VarDecl, encoded: List<Short>) {
+        val string = (lastvar.value as StringLiteralValue).value
+        out("${lastvar.name}\t; ${lastvar.datatype} \"${escape(string).replace("\u0000", "<NULL>")}\"")
+        val outputBytes = encoded.map { "$" + it.toString(16).padStart(2, '0') }
+        for (chunk in outputBytes.chunked(16))
+            out("  .byte  " + chunk.joinToString())
+    }
+
+    private fun makeArrayFillDataUnsigned(decl: VarDecl): List<String> {
+        val array = (decl.value as ArrayLiteralValue).value
+        return when {
+            decl.datatype == DataType.ARRAY_UB ->
+                // byte array can never contain pointer-to types, so treat values as all integers
+                array.map {
+                    val number = (it as NumericLiteralValue).number.toInt()
+                    "$"+number.toString(16).padStart(2, '0')
+                }
+            decl.datatype== DataType.ARRAY_UW -> array.map {
+                if(it is NumericLiteralValue) {
+                    "$" + it.number.toInt().toString(16).padStart(4, '0')
+                } else {
+                    (it as AddressOf).identifier.nameInSource.joinToString(".")
+                }
+            }
+            else -> throw AssemblyError("invalid arraysize type")
+        }
+    }
+
+    private fun makeArrayFillDataSigned(decl: VarDecl): List<String> {
+        val array = (decl.value as ArrayLiteralValue).value
+
+        return when {
+            decl.datatype == DataType.ARRAY_UB ->
+                // byte array can never contain pointer-to types, so treat values as all integers
+                array.map {
+                    val number = (it as NumericLiteralValue).number.toInt()
+                    val hexnum = number.toString(16).padStart(2, '0')
+                    "$$hexnum"
+                }
+            decl.datatype == DataType.ARRAY_B ->
+                // byte array can never contain pointer-to types, so treat values as all integers
+                array.map {
+                    val number = (it as NumericLiteralValue).number.toInt()
+                    val hexnum = number.absoluteValue.toString(16).padStart(2, '0')
+                    if(number>=0)
+                        "$$hexnum"
+                    else
+                        "-$$hexnum"
+                }
+            decl.datatype== DataType.ARRAY_UW -> array.map {
+                val number = (it as NumericLiteralValue).number.toInt()
+                val hexnum = number.toString(16).padStart(4, '0')
+                "$$hexnum"
+            }
+            decl.datatype== DataType.ARRAY_W -> array.map {
+                val number = (it as NumericLiteralValue).number.toInt()
+                val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
+                if(number>=0)
+                    "$$hexnum"
+                else
+                    "-$$hexnum"
+            }
+            else -> throw AssemblyError("invalid arraysize type ${decl.datatype}")
+        }
+    }
+
+    internal fun getFloatConst(number: Double): String {
+        // try to match the ROM float constants to save memory
+        val mflpt5 = MachineDefinition.Mflpt5.fromNumber(number)
+        val floatbytes = shortArrayOf(mflpt5.b0, mflpt5.b1, mflpt5.b2, mflpt5.b3, mflpt5.b4)
+        when {
+            floatbytes.contentEquals(shortArrayOf(0x00, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_ZERO"
+            floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "c64flt.FL_PIVAL"
+            floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "c64flt.FL_N32768"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FONE"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x35, 0x04, 0xf3, 0x34)) -> return "c64flt.FL_SQRHLF"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x35, 0x04, 0xf3, 0x34)) -> return "c64flt.FL_SQRTWO"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x80, 0x00, 0x00, 0x00)) -> return "c64flt.FL_NEGHLF"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x31, 0x72, 0x17, 0xf8)) -> return "c64flt.FL_LOG2"
+            floatbytes.contentEquals(shortArrayOf(0x84, 0x20, 0x00, 0x00, 0x00)) -> return "c64flt.FL_TENC"
+            floatbytes.contentEquals(shortArrayOf(0x9e, 0x6e, 0x6b, 0x28, 0x00)) -> return "c64flt.FL_NZMIL"
+            floatbytes.contentEquals(shortArrayOf(0x80, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FHALF"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x38, 0xaa, 0x3b, 0x29)) -> return "c64flt.FL_LOGEB2"
+            floatbytes.contentEquals(shortArrayOf(0x81, 0x49, 0x0f, 0xda, 0xa2)) -> return "c64flt.FL_PIHALF"
+            floatbytes.contentEquals(shortArrayOf(0x83, 0x49, 0x0f, 0xda, 0xa2)) -> return "c64flt.FL_TWOPI"
+            floatbytes.contentEquals(shortArrayOf(0x7f, 0x00, 0x00, 0x00, 0x00)) -> return "c64flt.FL_FR4"
+            else -> {
+                // attempt to correct for a few rounding issues
+                when (number.toBigDecimal().setScale(10, RoundingMode.HALF_DOWN).toDouble()) {
+                    3.1415926536 -> return "c64flt.FL_PIVAL"
+                    1.4142135624 -> return "c64flt.FL_SQRTWO"
+                    0.7071067812 -> return "c64flt.FL_SQRHLF"
+                    0.6931471806 -> return "c64flt.FL_LOG2"
+                    else -> {}
+                }
+
+                // no ROM float const for this value, create our own
+                val name = globalFloatConsts[number]
+                if(name!=null)
+                    return name
+                val newName = "prog8_float_const_${globalFloatConsts.size}"
+                globalFloatConsts[number] = newName
+                return newName
+            }
+        }
+    }
+
+    internal fun signExtendAtoMsb(destination: String) =
+            """
+        ora  #$7f
+        bmi  +
+        lda  #0
++       sta  $destination
+        """
+
+    internal fun asmIdentifierName(identifier: IdentifierReference): String {
+        val name = if(identifier.memberOfStruct(program.namespace)!=null) {
+            identifier.targetVarDecl(program.namespace)!!.name
+        } else {
+            identifier.nameInSource.joinToString(".")
+        }
+        return fixNameSymbols(name)
+    }
+
+    internal fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
+
+    private fun branchInstruction(condition: BranchCondition, complement: Boolean) =
+            if(complement) {
+                when (condition) {
+                    BranchCondition.CS -> "bcc"
+                    BranchCondition.CC -> "bcs"
+                    BranchCondition.EQ, BranchCondition.Z -> "beq"
+                    BranchCondition.NE, BranchCondition.NZ -> "bne"
+                    BranchCondition.VS -> "bvc"
+                    BranchCondition.VC -> "bvs"
+                    BranchCondition.MI, BranchCondition.NEG -> "bmi"
+                    BranchCondition.PL, BranchCondition.POS -> "bpl"
+                }
+            } else {
+                when (condition) {
+                    BranchCondition.CS -> "bcs"
+                    BranchCondition.CC -> "bcc"
+                    BranchCondition.EQ, BranchCondition.Z -> "beq"
+                    BranchCondition.NE, BranchCondition.NZ -> "bne"
+                    BranchCondition.VS -> "bvs"
+                    BranchCondition.VC -> "bvc"
+                    BranchCondition.MI, BranchCondition.NEG -> "bmi"
+                    BranchCondition.PL, BranchCondition.POS -> "bpl"
+                }
+            }
+
+    internal fun readAndPushArrayvalueWithIndexA(arrayDt: DataType, variable: IdentifierReference) {
+        val variablename = asmIdentifierName(variable)
+        when (arrayDt) {
+            DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+                out("  tay |  lda  $variablename,y |  sta  $ESTACK_LO_HEX,x |  dex")
+            DataType.ARRAY_UW, DataType.ARRAY_W ->
+                out("  asl  a |  tay |  lda  $variablename,y |  sta  $ESTACK_LO_HEX,x |  lda  $variablename+1,y |  sta  $ESTACK_HI_HEX,x | dex")
+            DataType.ARRAY_F ->
+                // index * 5 is done in the subroutine that's called
+                out("""
+                    sta  $ESTACK_LO_HEX,x
+                    dex
+                    lda  #<$variablename
+                    ldy  #>$variablename
+                    jsr  c64flt.push_float_from_indexed_var
+                """)
+            else ->
+                throw AssemblyError("weird array type")
+        }
+    }
+
+    internal fun saveRegister(register: Register) {
+        when(register) {
+            Register.A -> out("  pha")
+            Register.X -> out("  txa | pha")
+            Register.Y -> out("  tya | pha")
+        }
+    }
+
+    internal fun restoreRegister(register: Register) {
+        when(register) {
+            Register.A -> out("  pla")
+            Register.X -> out("  pla | tax")
+            Register.Y -> out("  pla | tay")
+        }
+    }
+
+    private fun translateSubroutine(sub: Subroutine) {
+        out("")
+        outputSourceLine(sub)
+
+        if(sub.isAsmSubroutine) {
+            if(sub.asmAddress!=null)
+                return  // already done at the memvars section
+
+            // asmsub with most likely just an inline asm in it
+            out("${sub.name}\t.proc")
+            sub.statements.forEach{ translate(it) }
+            out("  .pend\n")
+        } else {
+            // regular subroutine
+            out("${sub.name}\t.proc")
+            zeropagevars2asm(sub.statements)
+            memdefs2asm(sub.statements)
+            out("; statements")
+            sub.statements.forEach{ translate(it) }
+            out("; variables")
+            vardecls2asm(sub.statements)
+            out("  .pend\n")
+        }
+    }
+
+    internal fun translate(stmt: Statement) {
+        outputSourceLine(stmt)
+        when(stmt) {
+            is VarDecl, is StructDecl, is NopStatement -> {}
+            is Directive -> translate(stmt)
+            is Return -> translate(stmt)
+            is Subroutine -> translateSubroutine(stmt)
+            is InlineAssembly -> translate(stmt)
+            is FunctionCallStatement -> {
+                val functionName = stmt.target.nameInSource.last()
+                val builtinFunc = BuiltinFunctions[functionName]
+                if(builtinFunc!=null) {
+                    builtinFunctionsAsmGen.translateFunctioncallStatement(stmt, builtinFunc)
+                } else {
+                    functioncallAsmGen.translateFunctionCall(stmt)
+                    // discard any results from the stack:
+                    val sub = stmt.target.targetSubroutine(program.namespace)!!
+                    val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
+                    for((t, reg) in returns) {
+                        if(reg.stack) {
+                            if (t in IntegerDatatypes || t in PassByReferenceDatatypes) out("  inx")
+                            else if (t == DataType.FLOAT) out("  inx |  inx |  inx")
+                        }
+                    }
+                }
+            }
+            is Assignment -> assignmentAsmGen.translate(stmt)
+            is Jump -> translate(stmt)
+            is PostIncrDecr -> postincrdecrAsmGen.translate(stmt)
+            is Label -> translate(stmt)
+            is BranchStatement -> translate(stmt)
+            is IfStatement -> translate(stmt)
+            is ForLoop -> forloopsAsmGen.translate(stmt)
+            is Continue -> out("  jmp  ${loopContinueLabels.peek()}")
+            is Break -> out("  jmp  ${loopEndLabels.peek()}")
+            is WhileLoop -> translate(stmt)
+            is RepeatLoop -> translate(stmt)
+            is WhenStatement -> translate(stmt)
+            is BuiltinFunctionStatementPlaceholder -> throw AssemblyError("builtin function should not have placeholder anymore?")
+            is AnonymousScope -> translate(stmt)
+            is Block -> throw AssemblyError("block should have been handled elsewhere")
+        }
+    }
+
+    private fun translate(stmt: IfStatement) {
+        expressionsAsmGen.translateExpression(stmt.condition)
+        translateTestStack(stmt.condition.inferType(program).typeOrElse(DataType.STRUCT))
+        val elseLabel = makeLabel("if_else")
+        val endLabel = makeLabel("if_end")
+        out("  beq  $elseLabel")
+        translate(stmt.truepart)
+        out("  jmp  $endLabel")
+        out(elseLabel)
+        translate(stmt.elsepart)
+        out(endLabel)
+    }
+
+    private fun translateTestStack(dataType: DataType) {
+        when(dataType) {
+            in ByteDatatypes -> out("  inx |  lda  $ESTACK_LO_HEX,x")
+            in WordDatatypes -> out("  inx |  lda  $ESTACK_LO_HEX,x |  ora  $ESTACK_HI_HEX,x")
+            DataType.FLOAT -> throw AssemblyError("conditional value should be an integer (boolean)")
+            else -> throw AssemblyError("non-numerical dt")
+        }
+    }
+
+    private fun translate(stmt: WhileLoop) {
+        val whileLabel = makeLabel("while")
+        val endLabel = makeLabel("whileend")
+        loopEndLabels.push(endLabel)
+        loopContinueLabels.push(whileLabel)
+        out(whileLabel)
+        // TODO optimize for the simple cases, can we avoid stack use?
+        expressionsAsmGen.translateExpression(stmt.condition)
+        val conditionDt = stmt.condition.inferType(program)
+        if(!conditionDt.isKnown)
+            throw AssemblyError("unknown condition dt")
+        if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes) {
+            out("  inx |  lda  $ESTACK_LO_HEX,x  |  beq  $endLabel")
+        } else {
+            out("""
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  +
+                lda  $ESTACK_HI_HEX,x
+                beq  $endLabel
++  """)
+        }
+        translate(stmt.body)
+        out("  jmp  $whileLabel")
+        out(endLabel)
+        loopEndLabels.pop()
+        loopContinueLabels.pop()
+    }
+
+    private fun translate(stmt: RepeatLoop) {
+        val repeatLabel = makeLabel("repeat")
+        val endLabel = makeLabel("repeatend")
+        loopEndLabels.push(endLabel)
+        loopContinueLabels.push(repeatLabel)
+        out(repeatLabel)
+        // TODO optimize this for the simple cases, can we avoid stack use?
+        translate(stmt.body)
+        expressionsAsmGen.translateExpression(stmt.untilCondition)
+        val conditionDt = stmt.untilCondition.inferType(program)
+        if(!conditionDt.isKnown)
+            throw AssemblyError("unknown condition dt")
+        if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes) {
+            out("  inx |  lda  $ESTACK_LO_HEX,x  |  beq  $repeatLabel")
+        } else {
+            out("""
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  +
+                lda  $ESTACK_HI_HEX,x
+                beq  $repeatLabel
++ """)
+        }
+        out(endLabel)
+        loopEndLabels.pop()
+        loopContinueLabels.pop()
+    }
+
+    private fun translate(stmt: WhenStatement) {
+        expressionsAsmGen.translateExpression(stmt.condition)
+        val endLabel = makeLabel("choice_end")
+        val choiceBlocks = mutableListOf<Pair<String, AnonymousScope>>()
+        val conditionDt = stmt.condition.inferType(program)
+        if(!conditionDt.isKnown)
+            throw AssemblyError("unknown condition dt")
+        if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes)
+            out("  inx |  lda  $ESTACK_LO_HEX,x")
+        else
+            out("  inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x")
+        for(choice in stmt.choices) {
+            val choiceLabel = makeLabel("choice")
+            if(choice.values==null) {
+                // the else choice
+                translate(choice.statements)
+                out("  jmp  $endLabel")
+            } else {
+                choiceBlocks.add(Pair(choiceLabel, choice.statements))
+                for (cv in choice.values!!) {
+                    val value = (cv as NumericLiteralValue).number.toInt()
+                    if(conditionDt.typeOrElse(DataType.BYTE) in ByteDatatypes) {
+                        out("  cmp  #${value.toHex()} |  beq  $choiceLabel")
+                    } else {
+                        out("""
+                            cmp  #<${value.toHex()}
+                            bne  +
+                            cpy  #>${value.toHex()}
+                            beq  $choiceLabel
++                            
+                            """)
+                    }
+                }
+            }
+        }
+        for(choiceBlock in choiceBlocks) {
+            out(choiceBlock.first)
+            translate(choiceBlock.second)
+            out("  jmp  $endLabel")
+        }
+        out(endLabel)
+    }
+
+    private fun translate(stmt: Label) {
+        out(stmt.name)
+    }
+
+    private fun translate(scope: AnonymousScope) {
+        // note: the variables defined in an anonymous scope have been moved to their defining subroutine's scope
+        scope.statements.forEach{ translate(it) }
+    }
+
+    private fun translate(stmt: BranchStatement) {
+        if(stmt.truepart.containsNoCodeNorVars() && stmt.elsepart.containsCodeOrVars())
+            throw AssemblyError("only else part contains code, shoud have been switched already")
+
+        val jump = stmt.truepart.statements.first() as? Jump
+        if(jump!=null) {
+            // branch with only a jump
+            val instruction = branchInstruction(stmt.condition, false)
+            out("  $instruction  ${getJumpTarget(jump)}")
+            translate(stmt.elsepart)
+        } else {
+            if(stmt.elsepart.containsNoCodeNorVars()) {
+                val instruction = branchInstruction(stmt.condition, true)
+                val elseLabel = makeLabel("branch_else")
+                out("  $instruction  $elseLabel")
+                translate(stmt.truepart)
+                out(elseLabel)
+            } else {
+                val instruction = branchInstruction(stmt.condition, false)
+                val trueLabel = makeLabel("branch_true")
+                val endLabel = makeLabel("branch_end")
+                out("  $instruction  $trueLabel")
+                translate(stmt.elsepart)
+                out("  jmp  $endLabel")
+                out(trueLabel)
+                translate(stmt.truepart)
+                out(endLabel)
+            }
+        }
+    }
+
+    private fun translate(stmt: Directive) {
+        when(stmt.directive) {
+            "%asminclude" -> {
+                val sourcecode = loadAsmIncludeFile(stmt.args[0].str!!, stmt.definingModule().source)
+                val scopeprefix = stmt.args[1].str ?: ""
+                if(!scopeprefix.isBlank())
+                    out("$scopeprefix\t.proc")
+                assemblyLines.add(sourcecode.trimEnd().trimStart('\n'))
+                if(!scopeprefix.isBlank())
+                    out("  .pend\n")
+            }
+            "%asmbinary" -> {
+                val offset = if(stmt.args.size>1) ", ${stmt.args[1].int}" else ""
+                val length = if(stmt.args.size>2) ", ${stmt.args[2].int}" else ""
+                out("  .binary \"${stmt.args[0].str}\" $offset $length")
+            }
+            "%breakpoint" -> {
+                val label = "_prog8_breakpoint_${breakpointLabels.size+1}"
+                breakpointLabels.add(label)
+                out("$label\tnop")
+            }
+        }
+    }
+
+    private fun translate(jmp: Jump) {
+        out("  jmp  ${getJumpTarget(jmp)}")
+    }
+
+    private fun getJumpTarget(jmp: Jump): String {
+        return when {
+            jmp.identifier!=null -> asmIdentifierName(jmp.identifier)
+            jmp.generatedLabel!=null -> jmp.generatedLabel
+            jmp.address!=null -> jmp.address.toHex()
+            else -> "????"
+        }
+    }
+
+    private fun translate(ret: Return) {
+        ret.value?.let { expressionsAsmGen.translateExpression(it) }
+        out("  rts")
+    }
+
+    private fun translate(asm: InlineAssembly) {
+        val assembly = asm.assembly.trimEnd().trimStart('\n')
+        assemblyLines.add(assembly)
+    }
+
+    internal fun translateArrayIndexIntoA(expr: ArrayIndexedExpression) {
+        val index = expr.arrayspec.index
+        when (index) {
+            is NumericLiteralValue -> throw AssemblyError("this should be optimized directly")
+            is RegisterExpr -> {
+                when (index.register) {
+                    Register.A -> {}
+                    Register.X -> out("  txa")
+                    Register.Y -> out("  tya")
+                }
+            }
+            is IdentifierReference -> {
+                val indexName = asmIdentifierName(index)
+                out("  lda  $indexName")
+            }
+            else -> {
+                expressionsAsmGen.translateExpression(index)
+                out("  inx |  lda  $ESTACK_LO_HEX,x")
+            }
+        }
+    }
+
+    internal fun translateExpression(expression: Expression) =
+            expressionsAsmGen.translateExpression(expression)
+
+    internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FunctionSignature) =
+            builtinFunctionsAsmGen.translateFunctioncallExpression(functionCall, signature)
+
+    internal fun translateFunctionCall(functionCall: FunctionCall) =
+            functioncallAsmGen.translateFunctionCall(functionCall)
+
+    internal fun assignFromEvalResult(target: AssignTarget) =
+            assignmentAsmGen.assignFromEvalResult(target)
+
+    fun assignFromByteConstant(target: AssignTarget, value: Short) =
+            assignmentAsmGen.assignFromByteConstant(target, value)
+
+    fun assignFromWordConstant(target: AssignTarget, value: Int) =
+            assignmentAsmGen.assignFromWordConstant(target, value)
+
+    fun assignFromFloatConstant(target: AssignTarget, value: Double) =
+            assignmentAsmGen.assignFromFloatConstant(target, value)
+
+    fun assignFromByteVariable(target: AssignTarget, variable: IdentifierReference) =
+            assignmentAsmGen.assignFromByteVariable(target, variable)
+
+    fun assignFromWordVariable(target: AssignTarget, variable: IdentifierReference) =
+            assignmentAsmGen.assignFromWordVariable(target, variable)
+
+    fun assignFromFloatVariable(target: AssignTarget, variable: IdentifierReference) =
+            assignmentAsmGen.assignFromFloatVariable(target, variable)
+
+    fun assignFromRegister(target: AssignTarget, register: Register) =
+            assignmentAsmGen.assignFromRegister(target, register)
+
+    fun assignFromMemoryByte(target: AssignTarget, address: Int?, identifier: IdentifierReference?) =
+            assignmentAsmGen.assignFromMemoryByte(target, address, identifier)
+}

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

@@ -1,4 +1,4 @@
-package prog8.compiler.target.c64
+package prog8.compiler.target.c64.codegen
 
 import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
@@ -54,7 +54,7 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
         numberOfOptimizations++
     }
 
-    // TODO more assembly optimizations?
+    // TODO more assembly optimizations
 
     return numberOfOptimizations
 }
@@ -89,7 +89,6 @@ fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>
                 lines[1].value.trim()=="dex" &&
                 lines[2].value.trim()=="inx" &&
                 lines[3].value.trim()=="lda  $ESTACK_LO_HEX,x") {
-            removeLines.add(lines[0].index)
             removeLines.add(lines[1].index)
             removeLines.add(lines[2].index)
             removeLines.add(lines[3].index)
@@ -102,7 +101,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
 
     // 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...
+    // @todo a better place to do this is in the Compiler instead and transform the Ast, and never even create the inefficient asm in the first place...
 
     val removeLines = mutableListOf<Int>()
     for (pair in linesByFourteen) {

compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt

@@ -0,0 +1,745 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.DirectMemoryWrite
+import prog8.ast.statements.VarDecl
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.toHex
+
+internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen) {
+
+    internal fun translate(assign: Assignment) {
+        if(assign.aug_op!=null)
+            throw AssemblyError("aug-op assignments should have been transformed to normal ones")
+
+        when(assign.value) {
+            is NumericLiteralValue -> {
+                val numVal = assign.value as NumericLiteralValue
+                when(numVal.type) {
+                    DataType.UBYTE, DataType.BYTE -> assignFromByteConstant(assign.target, numVal.number.toShort())
+                    DataType.UWORD, DataType.WORD -> assignFromWordConstant(assign.target, numVal.number.toInt())
+                    DataType.FLOAT -> assignFromFloatConstant(assign.target, numVal.number.toDouble())
+                    else -> throw AssemblyError("weird numval type")
+                }
+            }
+            is RegisterExpr -> {
+                assignFromRegister(assign.target, (assign.value as RegisterExpr).register)
+            }
+            is IdentifierReference -> {
+                val type = assign.target.inferType(program, assign).typeOrElse(DataType.STRUCT)
+                when(type) {
+                    DataType.UBYTE, DataType.BYTE -> assignFromByteVariable(assign.target, assign.value as IdentifierReference)
+                    DataType.UWORD, DataType.WORD -> assignFromWordVariable(assign.target, assign.value as IdentifierReference)
+                    DataType.FLOAT -> assignFromFloatVariable(assign.target, assign.value as IdentifierReference)
+                    else -> throw AssemblyError("unsupported assignment target type $type")
+                }
+            }
+            is AddressOf -> {
+                val identifier = (assign.value as AddressOf).identifier
+                assignFromAddressOf(assign.target, identifier)
+            }
+            is DirectMemoryRead -> {
+                val read = (assign.value as DirectMemoryRead)
+                when(read.addressExpression) {
+                    is NumericLiteralValue -> {
+                        val address = (read.addressExpression as NumericLiteralValue).number.toInt()
+                        assignFromMemoryByte(assign.target, address, null)
+                    }
+                    is IdentifierReference -> {
+                        assignFromMemoryByte(assign.target, null, read.addressExpression as IdentifierReference)
+                    }
+                    else -> {
+                        asmgen.translateExpression(read.addressExpression)
+                        TODO("read memory byte from result and put that in ${assign.target}")
+                    }
+                }
+            }
+            is PrefixExpression -> {
+                // TODO optimize common cases
+                asmgen.translateExpression(assign.value as PrefixExpression)
+                assignFromEvalResult(assign.target)
+            }
+            is BinaryExpression -> {
+                // TODO optimize common cases
+                asmgen.translateExpression(assign.value as BinaryExpression)
+                assignFromEvalResult(assign.target)
+            }
+            is ArrayIndexedExpression -> {
+                // TODO optimize common cases
+                val arrayExpr = assign.value as ArrayIndexedExpression
+                val arrayDt = arrayExpr.identifier.targetVarDecl(program.namespace)!!.datatype
+                val index = arrayExpr.arrayspec.index
+                if(index is NumericLiteralValue) {
+                    // constant array index value
+                    val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier)
+                    val indexValue = index.number.toInt() * ArrayElementTypes.getValue(arrayDt).memorySize()
+                    when (arrayDt) {
+                        DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+                            asmgen.out("  lda  $arrayVarName+$indexValue |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+                        DataType.ARRAY_UW, DataType.ARRAY_W ->
+                            asmgen.out("  lda  $arrayVarName+$indexValue |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  lda  $arrayVarName+$indexValue+1 |  sta  ${MachineDefinition.ESTACK_HI_HEX},x | dex")
+                        DataType.ARRAY_F ->
+                            asmgen.out("  lda  #<$arrayVarName+$indexValue |  ldy  #>$arrayVarName+$indexValue |  jsr  c64flt.push_float")
+                        else ->
+                            throw AssemblyError("weird array type")
+                    }
+                } else {
+                    asmgen.translateArrayIndexIntoA(arrayExpr)
+                    asmgen.readAndPushArrayvalueWithIndexA(arrayDt, arrayExpr.identifier)
+                }
+                assignFromEvalResult(assign.target)
+            }
+            is TypecastExpression -> {
+                val cast = assign.value as TypecastExpression
+                val sourceType = cast.expression.inferType(program)
+                val targetType = assign.target.inferType(program, assign)
+                if(sourceType.isKnown && targetType.isKnown &&
+                        (sourceType.typeOrElse(DataType.STRUCT) in ByteDatatypes && targetType.typeOrElse(DataType.STRUCT) in ByteDatatypes) ||
+                        (sourceType.typeOrElse(DataType.STRUCT) in WordDatatypes && targetType.typeOrElse(DataType.STRUCT) in WordDatatypes)) {
+                    // no need for a type cast
+                    assign.value = cast.expression
+                    translate(assign)
+                } else {
+                    asmgen.translateExpression(assign.value as TypecastExpression)
+                    assignFromEvalResult(assign.target)
+                }
+            }
+            is FunctionCall -> {
+                asmgen.translateExpression(assign.value as FunctionCall)
+                assignFromEvalResult(assign.target)
+            }
+            is ArrayLiteralValue, is StringLiteralValue -> TODO("string/array/struct assignment?")
+            is StructLiteralValue -> throw AssemblyError("struct literal value assignment should have been flattened")
+            is RangeExpr -> throw AssemblyError("range expression should have been changed into array values")
+        }
+    }
+
+    internal fun assignFromEvalResult(target: AssignTarget) {
+        val targetIdent = target.identifier
+        when {
+            target.register!=null -> {
+                if(target.register== Register.X)
+                    throw AssemblyError("can't pop into X register - use variable instead")
+                asmgen.out(" inx | ld${target.register.name.toLowerCase()}  ${MachineDefinition.ESTACK_LO_HEX},x ")
+            }
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                val targetDt = targetIdent.inferType(program).typeOrElse(DataType.STRUCT)
+                when(targetDt) {
+                    DataType.UBYTE, DataType.BYTE -> {
+                        asmgen.out(" inx | lda  ${MachineDefinition.ESTACK_LO_HEX},x  | sta  $targetName")
+                    }
+                    DataType.UWORD, DataType.WORD -> {
+                        asmgen.out("""
+                            inx
+                            lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                            sta  $targetName
+                            lda  ${MachineDefinition.ESTACK_HI_HEX},x
+                            sta  $targetName+1
+                        """)
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("""
+                            lda  #<$targetName
+                            ldy  #>$targetName
+                            jsr  c64flt.pop_float
+                        """)
+                    }
+                    else -> throw AssemblyError("weird target variable type $targetDt")
+                }
+            }
+            target.memoryAddress!=null -> {
+                asmgen.out("  inx  | ldy  ${MachineDefinition.ESTACK_LO_HEX},x")
+                storeRegisterInMemoryAddress(Register.Y, target.memoryAddress)
+            }
+            target.arrayindexed!=null -> {
+                val arrayDt = target.arrayindexed!!.identifier.targetVarDecl(program.namespace)!!.datatype
+                val arrayVarName = asmgen.asmIdentifierName(target.arrayindexed!!.identifier)
+                asmgen.translateExpression(target.arrayindexed!!.arrayspec.index)
+                asmgen.out("  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x")
+                popAndWriteArrayvalueWithIndexA(arrayDt, arrayVarName)
+            }
+            else -> throw AssemblyError("weird assignment target $target")
+        }
+    }
+
+    internal fun assignFromAddressOf(target: AssignTarget, name: IdentifierReference) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        val struct = name.memberOfStruct(program.namespace)
+        val sourceName = if(struct!=null) {
+            // take the address of the first struct member instead
+            val decl = name.targetVarDecl(program.namespace)!!
+            val firstStructMember = struct.nameOfFirstMember()
+            // find the flattened var that belongs to this first struct member
+            val firstVarName = listOf(decl.name, firstStructMember)
+            val firstVar = name.definingScope().lookup(firstVarName, name) as VarDecl
+            firstVar.name
+        } else {
+            asmgen.fixNameSymbols(name.nameInSource.joinToString ("."))
+        }
+
+        when {
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out("""
+                        lda  #<$sourceName
+                        ldy  #>$sourceName
+                        sta  $targetName
+                        sty  $targetName+1
+                    """)
+            }
+            target.memoryAddress!=null -> {
+                TODO("assign address $sourceName to memory word $target")
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                TODO("assign address $sourceName to array $targetName [ $index ]")
+            }
+            else -> TODO("assign address $sourceName to $target")
+        }
+    }
+
+    internal fun assignFromWordVariable(target: AssignTarget, variable: IdentifierReference) {
+        val sourceName = asmgen.asmIdentifierName(variable)
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out("""
+                    lda  $sourceName
+                    ldy  $sourceName+1
+                    sta  $targetName
+                    sty  $targetName+1
+                """)
+            }
+            target.memoryAddress!=null -> {
+                TODO("assign wordvar $sourceName to memory ${target.memoryAddress}")
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                asmgen.out("  lda  $sourceName |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  lda  $sourceName+1 |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
+                asmgen.translateExpression(index)
+                asmgen.out("  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x")
+                val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
+                popAndWriteArrayvalueWithIndexA(arrayDt, targetName)
+            }
+            else -> TODO("assign wordvar to $target")
+        }
+    }
+
+    internal fun assignFromFloatVariable(target: AssignTarget, variable: IdentifierReference) {
+        val sourceName = asmgen.asmIdentifierName(variable)
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  $targetName
+                    lda  $sourceName+1
+                    sta  $targetName+1
+                    lda  $sourceName+2
+                    sta  $targetName+2
+                    lda  $sourceName+3
+                    sta  $targetName+3
+                    lda  $sourceName+4
+                    sta  $targetName+4
+                """)
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                asmgen.out("  lda  #<$sourceName |  ldy  #>$sourceName |  jsr  c64flt.push_float")
+                asmgen.translateExpression(index)
+                asmgen.out("  lda  #<$targetName |  ldy  #>$targetName |  jsr  c64flt.pop_float_to_indexed_var")
+            }
+            else -> TODO("assign floatvar to $target")
+        }
+    }
+
+    internal fun assignFromByteVariable(target: AssignTarget, variable: IdentifierReference) {
+        val sourceName = asmgen.asmIdentifierName(variable)
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            target.register!=null -> {
+                asmgen.out("  ld${target.register.name.toLowerCase()}  $sourceName")
+            }
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out("""
+                    lda  $sourceName
+                    sta  $targetName
+                    """)
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
+                asmgen.out("  lda  $sourceName |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+                asmgen.translateExpression(index)
+                asmgen.out("  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x")
+                popAndWriteArrayvalueWithIndexA(arrayDt, targetName)
+            }
+            target.memoryAddress != null -> {
+                val addressExpr = target.memoryAddress.addressExpression
+                val addressLv = addressExpr as? NumericLiteralValue
+                when {
+                    addressLv != null -> asmgen.out("  lda  $sourceName |  sta  ${addressLv.number.toHex()}")
+                    addressExpr is IdentifierReference -> {
+                        val targetName = asmgen.asmIdentifierName(addressExpr)
+                        asmgen.out("  lda  $sourceName |  sta  $targetName")
+                    }
+                    else -> {
+                        asmgen.translateExpression(addressExpr)
+                        asmgen.out("""
+     inx
+     lda  ${MachineDefinition.ESTACK_LO_HEX},x
+     ldy  ${MachineDefinition.ESTACK_HI_HEX},x
+     sta  (+) +1
+     sty  (+) +2
+     lda  $sourceName
++    sta  ${65535.toHex()}      ; modified              
+                            """)
+                    }
+                }
+            }
+            else -> TODO("assign bytevar to $target")
+        }
+    }
+
+    internal fun assignFromRegister(target: AssignTarget, register: Register) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out("  st${register.name.toLowerCase()}  $targetName")
+            }
+            target.register!=null -> {
+                when(register) {
+                    Register.A -> when(target.register) {
+                        Register.A -> {}
+                        Register.X -> asmgen.out("  tax")
+                        Register.Y -> asmgen.out("  tay")
+                    }
+                    Register.X -> when(target.register) {
+                        Register.A -> asmgen.out("  txa")
+                        Register.X -> {}
+                        Register.Y -> asmgen.out("  txy")
+                    }
+                    Register.Y -> when(target.register) {
+                        Register.A -> asmgen.out("  tya")
+                        Register.X -> asmgen.out("  tyx")
+                        Register.Y -> {}
+                    }
+                }
+            }
+            target.memoryAddress!=null -> {
+                storeRegisterInMemoryAddress(register, target.memoryAddress)
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                when (index) {
+                    is NumericLiteralValue -> {
+                        val memindex = index.number.toInt()
+                        when(register) {
+                            Register.A -> asmgen.out("  sta  $targetName+$memindex")
+                            Register.X -> asmgen.out("  stx  $targetName+$memindex")
+                            Register.Y -> asmgen.out("  sty  $targetName+$memindex")
+                        }
+                    }
+                    is RegisterExpr -> {
+                        when(register) {
+                            Register.A -> asmgen.out("  sta  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.X -> asmgen.out("  stx  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.Y -> asmgen.out("  sty  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                        }
+                        when(index.register) {
+                            Register.A -> {}
+                            Register.X -> asmgen.out("  txa")
+                            Register.Y -> asmgen.out("  tya")
+                        }
+                        asmgen.out("""
+                            tay
+                            lda  ${MachineDefinition.C64Zeropage.SCRATCH_B1}
+                            sta  $targetName,y
+                            """)
+                    }
+                    is IdentifierReference -> {
+                        when(register) {
+                            Register.A -> asmgen.out("  sta  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.X -> asmgen.out("  stx  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.Y -> asmgen.out("  sty  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                        }
+                        asmgen.out("""
+                            lda  ${asmgen.asmIdentifierName(index)}
+                            tay
+                            lda  ${MachineDefinition.C64Zeropage.SCRATCH_B1}
+                            sta  $targetName,y
+                        """)
+                    }
+                    else -> {
+                        asmgen.saveRegister(register)
+                        asmgen.translateExpression(index)
+                        asmgen.restoreRegister(register)
+                        when(register) {
+                            Register.A -> asmgen.out("  sta  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.X -> asmgen.out("  stx  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                            Register.Y -> asmgen.out("  sty  ${MachineDefinition.C64Zeropage.SCRATCH_B1}")
+                        }
+                        asmgen.out("""
+                            inx
+                            lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                            tay
+                            lda  ${MachineDefinition.C64Zeropage.SCRATCH_B1}
+                            sta  $targetName,y  
+                        """)
+                    }
+                }
+            }
+            else -> TODO("assign register $register to $target")
+        }
+    }
+
+    private fun storeRegisterInMemoryAddress(register: Register, memoryAddress: DirectMemoryWrite) {
+        val addressExpr = memoryAddress.addressExpression
+        val addressLv = addressExpr as? NumericLiteralValue
+        val registerName = register.name.toLowerCase()
+        when {
+            addressLv != null -> asmgen.out("  st$registerName  ${addressLv.number.toHex()}")
+            addressExpr is IdentifierReference -> {
+                val targetName = asmgen.asmIdentifierName(addressExpr)
+                when(register) {
+                    Register.A -> asmgen.out("""
+                        ldy  $targetName
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1}
+                        ldy  $targetName+1
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1+1}
+                        ldy  #0
+                        sta  (${MachineDefinition.C64Zeropage.SCRATCH_W1}),y
+                        """)
+                    Register.X -> asmgen.out("""
+                        txa
+                        ldy  $targetName
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1}
+                        ldy  $targetName+1
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1+1}
+                        ldy  #0
+                        sta  (${MachineDefinition.C64Zeropage.SCRATCH_W1}),y
+                        """)
+                    Register.Y -> asmgen.out("""
+                        tya
+                        ldy  $targetName
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1}
+                        ldy  $targetName+1
+                        sty  ${MachineDefinition.C64Zeropage.SCRATCH_W1+1}
+                        ldy  #0
+                        sta  (${MachineDefinition.C64Zeropage.SCRATCH_W1}),y
+                        """)
+                }
+            }
+            else -> {
+                asmgen.saveRegister(register)
+                asmgen.translateExpression(addressExpr)
+                asmgen.restoreRegister(register)
+                when (register) {
+                    Register.A -> asmgen.out("  tay")
+                    Register.X -> throw AssemblyError("can't use X register here")
+                    Register.Y -> {}
+                }
+                asmgen.out("""
+     inx
+     lda  ${MachineDefinition.ESTACK_LO_HEX},x
+     sta  (+) +1
+     lda  ${MachineDefinition.ESTACK_HI_HEX},x
+     sta  (+) +2
++    sty  ${65535.toHex()}      ; modified              
+                            """)
+            }
+        }
+    }
+
+    internal fun assignFromWordConstant(target: AssignTarget, word: Int) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                if(word ushr 8 == word and 255) {
+                    // lsb=msb
+                    asmgen.out("""
+                    lda  #${(word and 255).toHex()}
+                    sta  $targetName
+                    sta  $targetName+1
+                """)
+                } else {
+                    asmgen.out("""
+                    lda  #<${word.toHex()}
+                    ldy  #>${word.toHex()}
+                    sta  $targetName
+                    sty  $targetName+1
+                """)
+                }
+            }
+            target.memoryAddress!=null -> {
+                TODO("assign word $word to memory ${target.memoryAddress}")
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                // TODO optimize common cases
+                asmgen.translateExpression(index)
+                asmgen.out("""
+                    inx
+                    lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                    asl  a
+                    tay
+                    lda  #<${word.toHex()}
+                    sta  $targetName,y
+                    lda  #>${word.toHex()}
+                    sta  $targetName+1,y
+                """)
+            }
+            else -> TODO("assign word $word to $target")
+        }
+    }
+
+    internal fun assignFromByteConstant(target: AssignTarget, byte: Short) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        when {
+            target.register!=null -> {
+                asmgen.out("  ld${target.register.name.toLowerCase()}  #${byte.toHex()}")
+            }
+            targetIdent!=null -> {
+                val targetName = asmgen.asmIdentifierName(targetIdent)
+                asmgen.out(" lda  #${byte.toHex()} |  sta  $targetName ")
+            }
+            target.memoryAddress!=null -> {
+                asmgen.out("  ldy  #${byte.toHex()}")
+                storeRegisterInMemoryAddress(Register.Y, target.memoryAddress)
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                // TODO optimize common cases
+                asmgen.translateExpression(index)
+                asmgen.out("""
+                    inx
+                    ldy  ${MachineDefinition.ESTACK_LO_HEX},x
+                    lda  #${byte.toHex()}
+                    sta  $targetName,y
+                """)
+            }
+            else -> TODO("assign byte $byte to $target")
+        }
+    }
+
+    internal fun assignFromFloatConstant(target: AssignTarget, float: Double) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        if(float==0.0) {
+            // optimized case for float zero
+            when {
+                targetIdent != null -> {
+                    val targetName = asmgen.asmIdentifierName(targetIdent)
+                    asmgen.out("""
+                            lda  #0
+                            sta  $targetName
+                            sta  $targetName+1
+                            sta  $targetName+2
+                            sta  $targetName+3
+                            sta  $targetName+4
+                        """)
+                }
+                targetArrayIdx!=null -> {
+                    val index = targetArrayIdx.arrayspec.index
+                    val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                    if(index is NumericLiteralValue) {
+                        val indexValue = index.number.toInt() * MachineDefinition.Mflpt5.MemorySize
+                        asmgen.out("""
+                            lda  #0
+                            sta  $targetName+$indexValue
+                            sta  $targetName+$indexValue+1
+                            sta  $targetName+$indexValue+2
+                            sta  $targetName+$indexValue+3
+                            sta  $targetName+$indexValue+4
+                        """)
+                    } else {
+                        asmgen.translateExpression(index)
+                        asmgen.out("""
+                        inx
+                        lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                        asl  a
+                        asl  a
+                        clc
+                        adc  ${MachineDefinition.ESTACK_LO_HEX},x
+                        tay
+                        lda  #0
+                        sta  $targetName,y
+                        sta  $targetName+1,y
+                        sta  $targetName+2,y
+                        sta  $targetName+3,y
+                        sta  $targetName+4,y
+                    """) // TODO use a subroutine for this
+                    }
+                }
+                else -> TODO("assign float 0.0 to $target")
+            }
+        } else {
+            // non-zero value
+            val constFloat = asmgen.getFloatConst(float)
+            when {
+                targetIdent != null -> {
+                    val targetName = asmgen.asmIdentifierName(targetIdent)
+                    asmgen.out("""
+                            lda  $constFloat
+                            sta  $targetName
+                            lda  $constFloat+1
+                            sta  $targetName+1
+                            lda  $constFloat+2
+                            sta  $targetName+2
+                            lda  $constFloat+3
+                            sta  $targetName+3
+                            lda  $constFloat+4
+                            sta  $targetName+4
+                        """)
+                }
+                targetArrayIdx!=null -> {
+                    val index = targetArrayIdx.arrayspec.index
+                    val arrayVarName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                    if(index is NumericLiteralValue) {
+                        val indexValue = index.number.toInt() * MachineDefinition.Mflpt5.MemorySize
+                        asmgen.out("""
+                            lda  $constFloat
+                            sta  $arrayVarName+$indexValue
+                            lda  $constFloat+1
+                            sta  $arrayVarName+$indexValue+1
+                            lda  $constFloat+2
+                            sta  $arrayVarName+$indexValue+2
+                            lda  $constFloat+3
+                            sta  $arrayVarName+$indexValue+3
+                            lda  $constFloat+4
+                            sta  $arrayVarName+$indexValue+4
+                        """)
+                    } else {
+                        asmgen.translateArrayIndexIntoA(targetArrayIdx)
+                        asmgen.out("""
+                            sta  ${MachineDefinition.C64Zeropage.SCRATCH_REG}
+                            asl  a
+                            asl  a
+                            clc
+                            adc  ${MachineDefinition.C64Zeropage.SCRATCH_REG}
+                            tay
+                            lda  $constFloat
+                            sta  $arrayVarName,y
+                            lda  $constFloat+1
+                            sta  $arrayVarName+1,y
+                            lda  $constFloat+2
+                            sta  $arrayVarName+2,y
+                            lda  $constFloat+3
+                            sta  $arrayVarName+3,y
+                            lda  $constFloat+4
+                            sta  $arrayVarName+4,y
+                        """)        // TODO use a subroutine for this
+                    }
+                }
+                else -> TODO("assign float $float to $target")
+            }
+        }
+    }
+
+    internal fun assignFromMemoryByte(target: AssignTarget, address: Int?, identifier: IdentifierReference?) {
+        val targetIdent = target.identifier
+        val targetArrayIdx = target.arrayindexed
+        if(address!=null) {
+            when {
+                target.register!=null -> {
+                    asmgen.out("  ld${target.register.name.toLowerCase()}  ${address.toHex()}")
+                }
+                targetIdent!=null -> {
+                    val targetName = asmgen.asmIdentifierName(targetIdent)
+                    asmgen.out("""
+                        lda  ${address.toHex()}
+                        sta  $targetName
+                        """)
+                }
+                target.memoryAddress!=null -> {
+                    asmgen.out("  ldy  ${address.toHex()}")
+                    storeRegisterInMemoryAddress(Register.Y, target.memoryAddress)
+                }
+                targetArrayIdx!=null -> {
+                    val index = targetArrayIdx.arrayspec.index
+                    val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                    TODO("assign memory byte at $address to array $targetName [ $index ]")
+                }
+                else -> TODO("assign memory byte $target")
+            }
+        }
+        else if(identifier!=null) {
+            val sourceName = asmgen.asmIdentifierName(identifier)
+            when {
+                target.register!=null -> {
+                    asmgen.out("""
+                        ldy  #0
+                        lda  ($sourceName),y
+                    """)
+                    when(target.register){
+                        Register.A -> {}
+                        Register.X -> asmgen.out("  tax")
+                        Register.Y -> asmgen.out("  tay")
+                    }
+                }
+                targetIdent!=null -> {
+                    val targetName = asmgen.asmIdentifierName(targetIdent)
+                    asmgen.out("""
+                        ldy  #0
+                        lda  ($sourceName),y
+                        sta  $targetName
+                    """)
+                }
+                target.memoryAddress!=null -> {
+                    asmgen.out("  ldy  $sourceName")
+                    storeRegisterInMemoryAddress(Register.Y, target.memoryAddress)
+                }
+                targetArrayIdx!=null -> {
+                    val index = targetArrayIdx.arrayspec.index
+                    val targetName = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                    TODO("assign memory byte $sourceName to array $targetName [ $index ]")
+                }
+                else -> TODO("assign memory byte $target")
+            }
+        }
+    }
+
+    private fun popAndWriteArrayvalueWithIndexA(arrayDt: DataType, variablename: String) {
+        when (arrayDt) {
+            DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+                asmgen.out("  tay |  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x  | sta  $variablename,y")
+            DataType.ARRAY_UW, DataType.ARRAY_W ->
+                asmgen.out("  asl  a |  tay |  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x |  sta  $variablename,y |  lda  ${MachineDefinition.ESTACK_HI_HEX},x |  sta $variablename+1,y")
+            DataType.ARRAY_F ->
+                // index * 5 is done in the subroutine that's called
+                asmgen.out("""
+                    sta  ${MachineDefinition.ESTACK_LO_HEX},x
+                    dex
+                    lda  #<$variablename
+                    ldy  #>$variablename
+                    jsr  c64flt.pop_float_to_indexed_var
+                """)
+            else ->
+                throw AssemblyError("weird array type")
+        }
+    }
+}

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

@@ -0,0 +1,411 @@
+package prog8.compiler.target.c64.codegen
+
+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.target.c64.MachineDefinition
+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.toHex
+import prog8.functions.FunctionSignature
+
+internal class BuiltinFunctionsAsmGen(private val program: Program, private val asmgen: AsmGen) {
+
+    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).typeOrElse(DataType.STRUCT) !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.typeOrElse(DataType.STRUCT)) {
+                    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)
+            }
+            "strlen" -> {
+                outputPushAddressOfIdentifier(fcall.arglist[0])
+                asmgen.out("  jsr  prog8_lib.func_strlen")
+            }
+            "min", "max", "sum" -> {
+                outputPushAddressAndLenghtOfArray(fcall.arglist[0])
+                val dt = fcall.arglist.single().inferType(program)
+                when (dt.typeOrElse(DataType.STRUCT)) {
+                    DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_ub")
+                    DataType.ARRAY_B -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
+                    DataType.ARRAY_UW -> asmgen.out("  jsr  prog8_lib.func_${functionName}_uw")
+                    DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
+                    DataType.ARRAY_F -> asmgen.out("  jsr  c64flt.func_${functionName}_f")
+                    else -> throw AssemblyError("weird type $dt")
+                }
+            }
+            "any", "all" -> {
+                outputPushAddressAndLenghtOfArray(fcall.arglist[0])
+                val dt = fcall.arglist.single().inferType(program)
+                when (dt.typeOrElse(DataType.STRUCT)) {
+                    DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
+                    DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
+                    DataType.ARRAY_F -> asmgen.out("  jsr  c64flt.func_${functionName}_f")
+                    else -> throw AssemblyError("weird type $dt")
+                }
+            }
+            "sgn" -> {
+                translateFunctionArguments(fcall.arglist, func)
+                val dt = fcall.arglist.single().inferType(program)
+                when(dt.typeOrElse(DataType.STRUCT)) {
+                    DataType.UBYTE -> asmgen.out("  jsr  math.sign_ub")
+                    DataType.BYTE -> asmgen.out("  jsr  math.sign_b")
+                    DataType.UWORD -> asmgen.out("  jsr  math.sign_uw")
+                    DataType.WORD -> asmgen.out("  jsr  math.sign_w")
+                    DataType.FLOAT -> asmgen.out("  jsr  c64flt.sign_f")
+                    else -> throw AssemblyError("weird type $dt")
+                }
+            }
+            "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.typeOrElse(DataType.STRUCT)) {
+                    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 -> {
+                        when (what) {
+                            is ArrayIndexedExpression -> TODO("lsl sbyte $what")
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out(" asl  $variable |  rol  $variable+1")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "lsr" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)
+                when (dt.typeOrElse(DataType.STRUCT)) {
+                    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 -> {
+                        when (what) {
+                            is ArrayIndexedExpression -> TODO("lsr sbyte $what")
+                            is DirectMemoryRead -> TODO("lsr sbyte $what")
+                            is RegisterExpr -> TODO("lsr sbyte $what")
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  lda  $variable |  asl  a |  ror  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    DataType.UWORD -> {
+                        when (what) {
+                            is ArrayIndexedExpression -> TODO("lsr uword $what")
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out(" lsr  $variable+1 |  ror  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    DataType.WORD -> {
+                        when (what) {
+                            is ArrayIndexedExpression -> TODO("lsr sword $what")
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  lda  $variable+1 |  asl a  |  ror  $variable+1 |  ror  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "rol" -> {
+                // in-place
+                val what = fcall.arglist.single()
+                val dt = what.inferType(program)
+                when (dt.typeOrElse(DataType.STRUCT)) {
+                    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.typeOrElse(DataType.STRUCT)) {
+                    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.typeOrElse(DataType.STRUCT)) {
+                    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.typeOrElse(DataType.STRUCT)) {
+                    DataType.UBYTE -> {
+                        TODO("ror2 ubyte")
+                    }
+                    DataType.UWORD -> {
+                        TODO("ror2 uword")
+                    }
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "sort" -> {
+                val variable = fcall.arglist.single()
+                if(variable is IdentifierReference) {
+                    val decl = variable.targetVarDecl(program.namespace)!!
+                    val varName = asmgen.asmIdentifierName(variable)
+                    val numElements = decl.arraysize!!.size()
+                    when(decl.datatype) {
+                        DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                            asmgen.out("""
+                                lda  #<$varName
+                                ldy  #>$varName
+                                sta  ${C64Zeropage.SCRATCH_W1}
+                                sty  ${C64Zeropage.SCRATCH_W1+1}
+                                lda  #$numElements
+                                sta  ${C64Zeropage.SCRATCH_B1}
+                            """)
+                            asmgen.out(if(decl.datatype==DataType.ARRAY_UB) "  jsr  prog8_lib.sort_ub" else "  jsr  prog8_lib.sort_b")
+                        }
+                        DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                            asmgen.out("""
+                                lda  #<$varName
+                                ldy  #>$varName
+                                sta  ${C64Zeropage.SCRATCH_W1}
+                                sty  ${C64Zeropage.SCRATCH_W1+1}
+                                lda  #$numElements
+                                sta  ${C64Zeropage.SCRATCH_B1}
+                            """)
+                            asmgen.out(if(decl.datatype==DataType.ARRAY_UW) "  jsr  prog8_lib.sort_uw" else "  jsr  prog8_lib.sort_w")
+                        }
+                        DataType.ARRAY_F -> TODO("sort floats (consider another solution if possible - this will be very slow, if ever implemented)")
+                        else -> throw AssemblyError("weird type")
+                    }
+                }
+                else
+                    throw AssemblyError("weird type")
+            }
+            "reverse" -> {
+                val variable = fcall.arglist.single()
+                if (variable is IdentifierReference) {
+                    val decl = variable.targetVarDecl(program.namespace)!!
+                    val varName = asmgen.asmIdentifierName(variable)
+                    val numElements = decl.arraysize!!.size()
+                    when (decl.datatype) {
+                        DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                            asmgen.out("""
+                                lda  #<$varName
+                                ldy  #>$varName
+                                sta  ${C64Zeropage.SCRATCH_W1}
+                                sty  ${C64Zeropage.SCRATCH_W1 + 1}
+                                lda  #$numElements
+                                jsr  prog8_lib.reverse_b
+                            """)
+                        }
+                        DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                            asmgen.out("""
+                                lda  #<$varName
+                                ldy  #>$varName
+                                sta  ${C64Zeropage.SCRATCH_W1}
+                                sty  ${C64Zeropage.SCRATCH_W1 + 1}
+                                lda  #$numElements
+                                jsr  prog8_lib.reverse_w
+                            """)
+                        }
+                        DataType.ARRAY_F -> TODO("reverse floats (consider another solution if possible - this will be quite slow, if ever implemented)")
+                        else -> throw AssemblyError("weird type")
+                    }
+                }
+            }
+            else -> {
+                translateFunctionArguments(fcall.arglist, func)
+                asmgen.out("  jsr  prog8_lib.func_$functionName")
+            }
+        }
+    }
+
+    private fun outputPushAddressAndLenghtOfArray(arg: Expression) {
+        arg as IdentifierReference
+        val identifierName = asmgen.asmIdentifierName(arg)
+        val size = arg.targetVarDecl(program.namespace)!!.arraysize!!.size()!!
+        asmgen.out("""
+                    lda  #<$identifierName
+                    sta  $ESTACK_LO_HEX,x
+                    lda  #>$identifierName
+                    sta  $ESTACK_HI_HEX,x
+                    dex
+                    lda  #$size
+                    sta  $ESTACK_LO_HEX,x
+                    dex
+                    """)
+    }
+
+    private fun outputPushAddressOfIdentifier(arg: Expression) {
+        val identifierName = asmgen.asmIdentifierName(arg as IdentifierReference)
+        asmgen.out("""
+                    lda  #<$identifierName
+                    sta  $ESTACK_LO_HEX,x
+                    lda  #>$identifierName
+                    sta  $ESTACK_HI_HEX,x
+                    dex
+                    """)
+    }
+
+    private fun translateFunctionArguments(args: MutableList<Expression>, signature: FunctionSignature) {
+        args.forEach {
+            asmgen.translateExpression(it)
+        }
+    }
+
+}

compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt

@@ -0,0 +1,431 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.toHex
+import prog8.functions.BuiltinFunctions
+import kotlin.math.absoluteValue
+
+internal class ExpressionsAsmGen(private val program: Program, private val asmgen: AsmGen) {
+
+    internal fun translateExpression(expression: Expression) {
+        when(expression) {
+            is PrefixExpression -> translateExpression(expression)
+            is BinaryExpression -> translateExpression(expression)
+            is ArrayIndexedExpression -> translatePushFromArray(expression)
+            is TypecastExpression -> translateExpression(expression)
+            is AddressOf -> translateExpression(expression)
+            is DirectMemoryRead -> translateExpression(expression)
+            is NumericLiteralValue -> translateExpression(expression)
+            is RegisterExpr -> translateExpression(expression)
+            is IdentifierReference -> translateExpression(expression)
+            is FunctionCall -> translateExpression(expression)
+            is ArrayLiteralValue, is StringLiteralValue -> TODO("string/array/struct assignment?")
+            is StructLiteralValue -> throw AssemblyError("struct literal value assignment should have been flattened")
+            is RangeExpr -> throw AssemblyError("range expression should have been changed into array values")
+        }
+    }
+
+    private fun translateExpression(expression: FunctionCall) {
+        val functionName = expression.target.nameInSource.last()
+        val builtinFunc = BuiltinFunctions[functionName]
+        if (builtinFunc != null) {
+            asmgen.translateFunctioncallExpression(expression, builtinFunc)
+        } else {
+            asmgen.translateFunctionCall(expression)
+            val sub = expression.target.targetSubroutine(program.namespace)!!
+            val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
+            for ((_, reg) in returns) {
+                if (!reg.stack) {
+                    // result value in cpu or status registers, put it on the stack
+                    if (reg.registerOrPair != null) {
+                        when (reg.registerOrPair) {
+                            RegisterOrPair.A -> asmgen.out("  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+                            RegisterOrPair.Y -> asmgen.out("  tya |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+                            RegisterOrPair.AY -> asmgen.out("  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  tya |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
+                            RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY -> throw AssemblyError("can't push X register - use a variable")
+                        }
+                    }
+                    // return value from a statusregister is not put on the stack, it should be acted on via a conditional branch such as if_cc
+                }
+            }
+        }
+    }
+
+    private fun translateExpression(expr: TypecastExpression) {
+        translateExpression(expr.expression)
+        when(expr.expression.inferType(program).typeOrElse(DataType.STRUCT)) {
+            DataType.UBYTE -> {
+                when(expr.type) {
+                    DataType.UBYTE, DataType.BYTE -> {}
+                    DataType.UWORD, DataType.WORD -> asmgen.out("  lda  #0  |  sta  ${MachineDefinition.ESTACK_HI_PLUS1_HEX},x")
+                    DataType.FLOAT -> asmgen.out(" jsr  c64flt.stack_ub2float")
+                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.BYTE -> {
+                when(expr.type) {
+                    DataType.UBYTE, DataType.BYTE -> {}
+                    DataType.UWORD, DataType.WORD -> asmgen.out("  lda  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x  |  ${asmgen.signExtendAtoMsb("${MachineDefinition.ESTACK_HI_PLUS1_HEX},x")}")
+                    DataType.FLOAT -> asmgen.out(" jsr  c64flt.stack_b2float")
+                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.UWORD -> {
+                when(expr.type) {
+                    DataType.BYTE, DataType.UBYTE -> {}
+                    DataType.WORD, DataType.UWORD -> {}
+                    DataType.FLOAT -> asmgen.out(" jsr  c64flt.stack_uw2float")
+                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.WORD -> {
+                when(expr.type) {
+                    DataType.BYTE, DataType.UBYTE -> {}
+                    DataType.WORD, DataType.UWORD -> {}
+                    DataType.FLOAT -> asmgen.out(" jsr  c64flt.stack_w2float")
+                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            DataType.FLOAT -> {
+                when(expr.type) {
+                    DataType.UBYTE -> asmgen.out(" jsr  c64flt.stack_float2uw")
+                    DataType.BYTE -> asmgen.out(" jsr  c64flt.stack_float2w")
+                    DataType.UWORD -> asmgen.out(" jsr  c64flt.stack_float2uw")
+                    DataType.WORD -> asmgen.out(" jsr  c64flt.stack_float2w")
+                    DataType.FLOAT -> {}
+                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            in PassByReferenceDatatypes -> throw AssemblyError("cannot case a pass-by-reference datatypes into something else")
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+    private fun translateExpression(expr: AddressOf) {
+        val name = asmgen.asmIdentifierName(expr.identifier)
+        asmgen.out("  lda  #<$name |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  lda  #>$name  |  sta  ${MachineDefinition.ESTACK_HI_HEX},x  | dex")
+    }
+
+    private fun translateExpression(expr: DirectMemoryRead) {
+        when(expr.addressExpression) {
+            is NumericLiteralValue -> {
+                val address = (expr.addressExpression as NumericLiteralValue).number.toInt()
+                asmgen.out("  lda  ${address.toHex()} |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+            }
+            is IdentifierReference -> {
+                val sourceName = asmgen.asmIdentifierName(expr.addressExpression as IdentifierReference)
+                asmgen.out("  lda  $sourceName |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+            }
+            else -> {
+                translateExpression(expr.addressExpression)
+                asmgen.out("  jsr  prog8_lib.read_byte_from_address")
+                asmgen.out("  sta  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x")
+            }
+        }
+    }
+
+    private fun translateExpression(expr: NumericLiteralValue) {
+        when(expr.type) {
+            DataType.UBYTE, DataType.BYTE -> asmgen.out(" lda  #${expr.number.toHex()}  | sta  ${MachineDefinition.ESTACK_LO_HEX},x  | dex")
+            DataType.UWORD, DataType.WORD -> asmgen.out("""
+                lda  #<${expr.number.toHex()}
+                sta  ${MachineDefinition.ESTACK_LO_HEX},x
+                lda  #>${expr.number.toHex()}
+                sta  ${MachineDefinition.ESTACK_HI_HEX},x
+                dex
+            """)
+            DataType.FLOAT -> {
+                val floatConst = asmgen.getFloatConst(expr.number.toDouble())
+                asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  c64flt.push_float")
+            }
+            else -> throw AssemblyError("weird type")
+        }
+    }
+
+    private fun translateExpression(expr: RegisterExpr) {
+        when(expr.register) {
+            Register.A -> asmgen.out(" sta  ${MachineDefinition.ESTACK_LO_HEX},x | dex")
+            Register.X -> throw AssemblyError("cannot push X - use a variable instead of the X register")
+            Register.Y -> asmgen.out(" tya |  sta  ${MachineDefinition.ESTACK_LO_HEX},x | dex")
+        }
+    }
+
+    private fun translateExpression(expr: IdentifierReference) {
+        val varname = asmgen.asmIdentifierName(expr)
+        when(expr.inferType(program).typeOrElse(DataType.STRUCT)) {
+            DataType.UBYTE, DataType.BYTE -> {
+                asmgen.out("  lda  $varname  |  sta  ${MachineDefinition.ESTACK_LO_HEX},x  |  dex")
+            }
+            DataType.UWORD, DataType.WORD, in ArrayDatatypes, in StringDatatypes -> {
+                // (for arrays and strings, push their address)
+                asmgen.out("  lda  $varname  |  sta  ${MachineDefinition.ESTACK_LO_HEX},x  |  lda  $varname+1 |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
+            }
+            DataType.FLOAT -> {
+                asmgen.out(" lda  #<$varname |  ldy  #>$varname|  jsr  c64flt.push_float")
+            }
+            else -> throw AssemblyError("stack push weird variable type $expr")
+        }
+    }
+
+    private val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40)
+    private val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40)
+    private val powersOfTwo = setOf(0,1,2,4,8,16,32,64,128,256)
+
+    private fun translateExpression(expr: BinaryExpression) {
+        val leftIDt = expr.left.inferType(program)
+        val rightIDt = expr.right.inferType(program)
+        if(!leftIDt.isKnown || !rightIDt.isKnown)
+            throw AssemblyError("can't infer type of both expression operands")
+
+        val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
+        val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
+        // see if we can apply some optimized routines
+        when(expr.operator) {
+            ">>" -> {
+                // bit-shifts are always by a constant number (for now)
+                translateExpression(expr.left)
+                val amount = expr.right.constValue(program)!!.number.toInt()
+                when (leftDt) {
+                    DataType.UBYTE -> repeat(amount) { asmgen.out("  lsr  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x") }
+                    DataType.BYTE -> repeat(amount) { asmgen.out("  lda  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x |  asl  a |  ror  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x") }
+                    DataType.UWORD -> repeat(amount) { asmgen.out("  lsr  ${MachineDefinition.ESTACK_HI_PLUS1_HEX},x |  ror  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x") }
+                    DataType.WORD -> repeat(amount) { asmgen.out("  lda  ${MachineDefinition.ESTACK_HI_PLUS1_HEX},x |  asl a  |  ror  ${MachineDefinition.ESTACK_HI_PLUS1_HEX},x |  ror  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x") }
+                    else -> throw AssemblyError("weird type")
+                }
+                return
+            }
+            "<<" -> {
+                // bit-shifts are always by a constant number (for now)
+                translateExpression(expr.left)
+                val amount = expr.right.constValue(program)!!.number.toInt()
+                if (leftDt in ByteDatatypes)
+                    repeat(amount) { asmgen.out("  asl  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x") }
+                else
+                    repeat(amount) { asmgen.out("  asl  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x |  rol  ${MachineDefinition.ESTACK_HI_PLUS1_HEX},x") }
+                return
+            }
+            "*" -> {
+                val value = expr.right.constValue(program)
+                if(value!=null) {
+                    if(rightDt in IntegerDatatypes) {
+                        val amount = value.number.toInt()
+                        if(amount in powersOfTwo)
+                            printWarning("${expr.right.position} multiplication by power of 2 should have been optimized into a left shift instruction: $amount")
+                        when(rightDt) {
+                            DataType.UBYTE -> {
+                                if(amount in optimizedByteMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  math.mul_byte_$amount")
+                                    return
+                                }
+                            }
+                            DataType.BYTE -> {
+                                if(amount in optimizedByteMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  math.mul_byte_$amount")
+                                    return
+                                }
+                                if(amount.absoluteValue in optimizedByteMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.mul_byte_${amount.absoluteValue}")
+                                    return
+                                }
+                            }
+                            DataType.UWORD -> {
+                                if(amount in optimizedWordMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  math.mul_word_$amount")
+                                    return
+                                }
+                            }
+                            DataType.WORD -> {
+                                if(amount in optimizedWordMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  math.mul_word_$amount")
+                                    return
+                                }
+                                if(amount.absoluteValue in optimizedWordMultiplications) {
+                                    translateExpression(expr.left)
+                                    asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.mul_word_${amount.absoluteValue}")
+                                    return
+                                }
+                            }
+                            else -> {}
+                        }
+                    }
+                }
+            }
+        }
+
+        // the general, non-optimized cases
+        translateExpression(expr.left)
+        translateExpression(expr.right)
+        if(leftDt!=rightDt)
+            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")     // is this strictly required always?
+        when (leftDt) {
+            in ByteDatatypes -> translateBinaryOperatorBytes(expr.operator, leftDt)
+            in WordDatatypes -> translateBinaryOperatorWords(expr.operator, leftDt)
+            DataType.FLOAT -> translateBinaryOperatorFloats(expr.operator)
+            else -> throw AssemblyError("non-numerical datatype")
+        }
+    }
+
+    private fun translateExpression(expr: PrefixExpression) {
+        translateExpression(expr.expression)
+        val type = expr.inferType(program).typeOrElse(DataType.STRUCT)
+        when(expr.operator) {
+            "+" -> {}
+            "-" -> {
+                when(type) {
+                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.neg_b")
+                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.neg_w")
+                    DataType.FLOAT -> asmgen.out("  jsr  c64flt.neg_f")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "~" -> {
+                when(type) {
+                    in ByteDatatypes ->
+                        asmgen.out("""
+                            lda  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                            eor  #255
+                            sta  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                            """)
+                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.inv_word")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            "not" -> {
+                when(type) {
+                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.not_byte")
+                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.not_word")
+                    else -> throw AssemblyError("weird type")
+                }
+            }
+            else -> throw AssemblyError("invalid prefix operator ${expr.operator}")
+        }
+    }
+
+    private fun translatePushFromArray(arrayExpr: ArrayIndexedExpression) {
+        // assume *reading* from an array
+        val index = arrayExpr.arrayspec.index
+        val arrayDt = arrayExpr.identifier.targetVarDecl(program.namespace)!!.datatype
+        val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier)
+        if(index is NumericLiteralValue) {
+            val elementDt = ArrayElementTypes.getValue(arrayDt)
+            val indexValue = index.number.toInt() * elementDt.memorySize()
+            when(elementDt) {
+                in ByteDatatypes -> {
+                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  dex")
+                }
+                in WordDatatypes -> {
+                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  ${MachineDefinition.ESTACK_LO_HEX},x |  lda  $arrayVarName+$indexValue+1 |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
+                }
+                DataType.FLOAT -> {
+                    asmgen.out("  lda  #<$arrayVarName+$indexValue |  ldy  #>$arrayVarName+$indexValue |  jsr  c64flt.push_float")
+                }
+                else -> throw AssemblyError("weird type")
+            }
+        } else {
+            asmgen.translateArrayIndexIntoA(arrayExpr)
+            asmgen.readAndPushArrayvalueWithIndexA(arrayDt, arrayExpr.identifier)
+        }
+    }
+
+    private fun translateBinaryOperatorBytes(operator: String, types: DataType) {
+        when(operator) {
+            "**" -> throw AssemblyError("** operator requires floats")
+            "*" -> asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
+            "/" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
+            "%" -> {
+                if(types==DataType.BYTE)
+                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
+                asmgen.out("  jsr prog8_lib.remainder_ub")
+            }
+            "+" -> asmgen.out("""
+                lda  ${MachineDefinition.ESTACK_LO_PLUS2_HEX},x
+                clc
+                adc  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                inx
+                sta  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                """)
+            "-" -> asmgen.out("""
+                lda  ${MachineDefinition.ESTACK_LO_PLUS2_HEX},x
+                sec
+                sbc  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                inx
+                sta  ${MachineDefinition.ESTACK_LO_PLUS1_HEX},x
+                """)
+            "<<", ">>" -> throw AssemblyError("bit-shifts not via stack")
+            "<" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.less_ub" else "  jsr  prog8_lib.less_b")
+            ">" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greater_ub" else "  jsr  prog8_lib.greater_b")
+            "<=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.lesseq_ub" else "  jsr  prog8_lib.lesseq_b")
+            ">=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greatereq_ub" else "  jsr  prog8_lib.greatereq_b")
+            "==" -> asmgen.out("  jsr  prog8_lib.equal_b")
+            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_b")
+            "&" -> asmgen.out("  jsr  prog8_lib.bitand_b")
+            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_b")
+            "|" -> asmgen.out("  jsr  prog8_lib.bitor_b")
+            "and" -> asmgen.out("  jsr  prog8_lib.and_b")
+            "or" -> asmgen.out("  jsr  prog8_lib.or_b")
+            "xor" -> asmgen.out("  jsr  prog8_lib.xor_b")
+            else -> throw AssemblyError("invalid operator $operator")
+        }
+    }
+
+    private fun translateBinaryOperatorWords(operator: String, types: DataType) {
+        when(operator) {
+            "**" -> throw AssemblyError("** operator requires floats")
+            "*" -> asmgen.out("  jsr  prog8_lib.mul_word")
+            "/" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
+            "%" -> {
+                if(types==DataType.WORD)
+                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
+                asmgen.out("  jsr prog8_lib.remainder_uw")
+            }
+            "+" -> asmgen.out("  jsr  prog8_lib.add_w")
+            "-" -> asmgen.out("  jsr  prog8_lib.sub_w")
+            "<<" -> throw AssemblyError("<< should not operate via stack")
+            ">>" -> throw AssemblyError(">> should not operate via stack")
+            "<" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.less_uw" else "  jsr  prog8_lib.less_w")
+            ">" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.greater_uw" else "  jsr  prog8_lib.greater_w")
+            "<=" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.lesseq_uw" else "  jsr  prog8_lib.lesseq_w")
+            ">=" -> asmgen.out(if(types==DataType.UWORD) "  jsr  prog8_lib.greatereq_uw" else "  jsr  prog8_lib.greatereq_w")
+            "==" -> asmgen.out("  jsr  prog8_lib.equal_w")
+            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_w")
+            "&" -> asmgen.out("  jsr  prog8_lib.bitand_w")
+            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_w")
+            "|" -> asmgen.out("  jsr  prog8_lib.bitor_w")
+            "and" -> asmgen.out("  jsr  prog8_lib.and_w")
+            "or" -> asmgen.out("  jsr  prog8_lib.or_w")
+            "xor" -> asmgen.out("  jsr  prog8_lib.xor_w")
+            else -> throw AssemblyError("invalid operator $operator")
+        }
+    }
+
+    private fun translateBinaryOperatorFloats(operator: String) {
+        when(operator) {
+            "**" -> asmgen.out(" jsr  c64flt.pow_f")
+            "*" -> asmgen.out("  jsr  c64flt.mul_f")
+            "/" -> asmgen.out("  jsr  c64flt.div_f")
+            "+" -> asmgen.out("  jsr  c64flt.add_f")
+            "-" -> asmgen.out("  jsr  c64flt.sub_f")
+            "<" -> asmgen.out("  jsr  c64flt.less_f")
+            ">" -> asmgen.out("  jsr  c64flt.greater_f")
+            "<=" -> asmgen.out("  jsr  c64flt.lesseq_f")
+            ">=" -> asmgen.out("  jsr  c64flt.greatereq_f")
+            "==" -> asmgen.out("  jsr  c64flt.equal_f")
+            "!=" -> asmgen.out("  jsr  c64flt.notequal_f")
+            "%", "<<", ">>", "&", "^", "|", "and", "or", "xor" -> throw AssemblyError("requires integer datatype")
+            else -> throw AssemblyError("invalid operator $operator")
+        }
+    }
+}

compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt

@@ -0,0 +1,561 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.Program
+import prog8.ast.base.DataType
+import prog8.ast.base.Register
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.RangeExpr
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.ForLoop
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.toHex
+import kotlin.math.absoluteValue
+
+
+internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen) {
+
+    internal fun translate(stmt: ForLoop) {
+        val iterableDt = stmt.iterable.inferType(program)
+        if(!iterableDt.isKnown)
+            throw AssemblyError("can't determine iterable dt")
+        when(stmt.iterable) {
+            is RangeExpr -> {
+                val range = (stmt.iterable as RangeExpr).toConstantIntegerRange()
+                if(range==null) {
+                    translateForOverNonconstRange(stmt, iterableDt.typeOrElse(DataType.STRUCT), stmt.iterable as RangeExpr)
+                } else {
+                    if (range.isEmpty())
+                        throw AssemblyError("empty range")
+                    translateForOverConstRange(stmt, iterableDt.typeOrElse(DataType.STRUCT), range)
+                }
+            }
+            is IdentifierReference -> {
+                translateForOverIterableVar(stmt, iterableDt.typeOrElse(DataType.STRUCT), stmt.iterable as IdentifierReference)
+            }
+            else -> throw AssemblyError("can't iterate over ${stmt.iterable}")
+        }
+    }
+
+    private fun translateForOverNonconstRange(stmt: ForLoop, iterableDt: DataType, range: RangeExpr) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        val continueLabel = asmgen.makeLabel("for_continue")
+        val counterLabel = asmgen.makeLabel("for_counter")
+        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopContinueLabels.push(continueLabel)
+        val stepsize=range.step.constValue(program)?.number
+        when (stepsize) {
+            1 -> {
+                when(iterableDt) {
+                    DataType.ARRAY_B, DataType.ARRAY_UB -> {
+                        if (stmt.loopRegister != null) {
+                            // loop register over range
+                            if(stmt.loopRegister!= Register.A)
+                                throw AssemblyError("can only use A")
+                            asmgen.translateExpression(range.to)
+                            asmgen.translateExpression(range.from)
+                            asmgen.out("""
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                sta  $loopLabel+1
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                sec
+                sbc  $loopLabel+1
+                adc  #0
+                sta  $counterLabel
+$loopLabel      lda  #0                 ; modified""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                inc  $loopLabel+1
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        } else {
+                            // loop over byte range via loopvar
+                            val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                            asmgen.translateExpression(range.to)
+                            asmgen.translateExpression(range.from)
+                            asmgen.out("""
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                sta  $varname
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                sec
+                sbc  $varname
+                adc  #0
+                sta  $counterLabel
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                inc  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                    }
+                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                        asmgen.translateExpression(range.to)
+                        asmgen.out("  inc  ${MachineDefinition.ESTACK_LO_HEX}+1,x |  bne  + |  inc  ${MachineDefinition.ESTACK_HI_HEX}+1,x |+  ")
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                                null, range.from, range.position)
+                        assignLoopvar.linkParents(stmt)
+                        asmgen.translate(assignLoopvar)
+                        asmgen.out(loopLabel)
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+                inc  $varname
+                bne  +
+                inc  $varname+1            
++               lda  ${MachineDefinition.ESTACK_HI_HEX}+1,x
+                cmp  $varname+1
+                bne  +
+                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
+                cmp  $varname
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel       inx""")
+                    }
+                    else -> throw AssemblyError("range expression can only be byte or word")
+                }
+            }
+            -1 -> {
+                when(iterableDt){
+                    DataType.ARRAY_B, DataType.ARRAY_UB -> {
+                        if (stmt.loopRegister != null) {
+                            // loop register over range
+                            if(stmt.loopRegister!= Register.A)
+                                throw AssemblyError("can only use A")
+                            asmgen.translateExpression(range.from)
+                            asmgen.translateExpression(range.to)
+                            asmgen.out("""
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
+                sta  $loopLabel+1
+                sec
+                sbc  ${MachineDefinition.ESTACK_LO_HEX},x
+                adc  #0
+                sta  $counterLabel
+                inx
+$loopLabel      lda  #0                 ; modified""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                dec  $loopLabel+1
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        } else {
+                            // loop over byte range via loopvar
+                            val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                            asmgen.translateExpression(range.from)
+                            asmgen.translateExpression(range.to)
+                            asmgen.out("""
+                inx
+                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
+                sta  $varname
+                sec
+                sbc  ${MachineDefinition.ESTACK_LO_HEX},x
+                adc  #0
+                sta  $counterLabel
+                inx
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                dec  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                    }
+                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                        asmgen.translateExpression(range.to)
+                        asmgen.out("""
+                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
+                bne  +
+                dec  ${MachineDefinition.ESTACK_HI_HEX}+1,x
++               dec  ${MachineDefinition.ESTACK_LO_HEX}+1,x                            
+                        """)
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                                null, range.from, range.position)
+                        assignLoopvar.linkParents(stmt)
+                        asmgen.translate(assignLoopvar)
+                        asmgen.out(loopLabel)
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+                lda  $varname
+                bne  +
+                dec  $varname+1
++               dec  $varname                
+                lda  ${MachineDefinition.ESTACK_HI_HEX}+1,x
+                cmp  $varname+1
+                bne  +
+                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
+                cmp  $varname
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel       inx""")
+                    }
+                    else -> throw AssemblyError("range expression can only be byte or word")
+                }
+            }
+            else -> when (iterableDt) {
+                DataType.ARRAY_UB, DataType.ARRAY_B -> TODO("non-const forloop bytes, step >1: $stepsize")
+                DataType.ARRAY_UW, DataType.ARRAY_W -> TODO("non-const forloop words, step >1: $stepsize")
+                else -> throw AssemblyError("range expression can only be byte or word")
+            }
+        }
+        asmgen.loopEndLabels.pop()
+        asmgen.loopContinueLabels.pop()
+    }
+
+    private fun translateForOverIterableVar(stmt: ForLoop, iterableDt: DataType, ident: IdentifierReference) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        val continueLabel = asmgen.makeLabel("for_continue")
+        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopContinueLabels.push(continueLabel)
+        val iterableName = asmgen.asmIdentifierName(ident)
+        val decl = ident.targetVarDecl(program.namespace)!!
+        when(iterableDt) {
+            DataType.STR, DataType.STR_S -> {
+                if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
+                    throw AssemblyError("can only use A")
+                asmgen.out("""
+                    lda  #<$iterableName
+                    ldy  #>$iterableName
+                    sta  $loopLabel+1
+                    sty  $loopLabel+2
+$loopLabel          lda  ${65535.toHex()}       ; modified
+                    beq  $endLabel""")
+                if(stmt.loopVar!=null)
+                    asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar!!)}")
+                asmgen.translate(stmt.body)
+                asmgen.out("""
+$continueLabel      inc  $loopLabel+1
+                    bne  $loopLabel
+                    inc  $loopLabel+2
+                    bne  $loopLabel
+$endLabel""")
+            }
+            DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter in such cases
+                val length = decl.arraysize!!.size()!!
+                if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
+                    throw AssemblyError("can only use A")
+                val counterLabel = asmgen.makeLabel("for_counter")
+                val modifiedLabel = asmgen.makeLabel("for_modified")
+                asmgen.out("""
+                    lda  #<$iterableName
+                    ldy  #>$iterableName
+                    sta  $modifiedLabel+1
+                    sty  $modifiedLabel+2
+                    ldy  #0
+$loopLabel          sty  $counterLabel
+$modifiedLabel      lda  ${65535.toHex()},y       ; modified""")
+                if(stmt.loopVar!=null)
+                    asmgen.out("  sta  ${asmgen.asmIdentifierName(stmt.loopVar!!)}")
+                asmgen.translate(stmt.body)
+                asmgen.out("""
+$continueLabel      ldy  $counterLabel
+                    iny
+                    cpy  #${length and 255}
+                    beq  $endLabel
+                    jmp  $loopLabel
+$counterLabel       .byte  0
+$endLabel""")
+            }
+            DataType.ARRAY_W, DataType.ARRAY_UW -> {
+                // TODO: optimize loop code when the length of the array is < 256, don't need a separate counter in such cases
+                val length = decl.arraysize!!.size()!! * 2
+                if(stmt.loopRegister!=null)
+                    throw AssemblyError("can't use register to loop over words")
+                val counterLabel = asmgen.makeLabel("for_counter")
+                val modifiedLabel = asmgen.makeLabel("for_modified")
+                val modifiedLabel2 = asmgen.makeLabel("for_modified2")
+                val loopvarName = asmgen.asmIdentifierName(stmt.loopVar!!)
+                asmgen.out("""
+                    lda  #<$iterableName
+                    ldy  #>$iterableName
+                    sta  $modifiedLabel+1
+                    sty  $modifiedLabel+2
+                    lda  #<$iterableName+1
+                    ldy  #>$iterableName+1
+                    sta  $modifiedLabel2+1
+                    sty  $modifiedLabel2+2
+                    ldy  #0
+$loopLabel          sty  $counterLabel
+$modifiedLabel      lda  ${65535.toHex()},y       ; modified
+                    sta  $loopvarName
+$modifiedLabel2     lda  ${65535.toHex()},y       ; modified
+                    sta  $loopvarName+1""")
+                asmgen.translate(stmt.body)
+                asmgen.out("""
+$continueLabel      ldy  $counterLabel
+                    iny
+                    iny
+                    cpy  #${length and 255}
+                    beq  $endLabel
+                    jmp  $loopLabel
+$counterLabel       .byte  0
+$endLabel""")
+            }
+            DataType.ARRAY_F -> {
+                throw AssemblyError("for loop with floating point variables is not supported")
+            }
+            else -> throw AssemblyError("can't iterate over $iterableDt")
+        }
+        asmgen.loopEndLabels.pop()
+        asmgen.loopContinueLabels.pop()
+    }
+
+    private fun translateForOverConstRange(stmt: ForLoop, iterableDt: DataType, range: IntProgression) {
+        // TODO: optimize loop code when the range is < 256 iterations, don't need a separate counter in such cases
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        val continueLabel = asmgen.makeLabel("for_continue")
+        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopContinueLabels.push(continueLabel)
+        when(iterableDt) {
+            DataType.ARRAY_B, DataType.ARRAY_UB -> {
+                val counterLabel = asmgen.makeLabel("for_counter")
+                if(stmt.loopRegister!=null) {
+
+                    // loop register over range
+
+                    if(stmt.loopRegister!= Register.A)
+                        throw AssemblyError("can only use A")
+                    when {
+                        range.step==1 -> {
+                            // step = 1
+                            asmgen.out("""
+                lda  #${range.first}
+                sta  $loopLabel+1
+                lda  #${range.last-range.first+1 and 255}
+                sta  $counterLabel
+$loopLabel      lda  #0                 ; modified""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                inc  $loopLabel+1
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        range.step==-1 -> {
+                            // step = -1
+                            asmgen.out("""
+                lda  #${range.first}
+                sta  $loopLabel+1
+                lda  #${range.first-range.last+1 and 255}
+                sta  $counterLabel
+$loopLabel      lda  #0                 ; modified """)
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                dec  $loopLabel+1
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        range.step >= 2 -> {
+                            // step >= 2
+                            asmgen.out("""
+                lda  #${(range.last-range.first) / range.step + 1}
+                sta  $counterLabel
+                lda  #${range.first}
+$loopLabel      pha""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  pla
+                dec  $counterLabel
+                beq  $endLabel
+                clc
+                adc  #${range.step}
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        else -> {
+                            // step <= -2
+                            asmgen.out("""
+                lda  #${(range.first-range.last) / range.step.absoluteValue + 1}
+                sta  $counterLabel
+                lda  #${range.first}
+$loopLabel      pha""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  pla
+                dec  $counterLabel
+                beq  $endLabel
+                sec
+                sbc  #${range.step.absoluteValue}
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                    }
+
+                } else {
+
+                    // loop over byte range via loopvar
+                    val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                    when {
+                        range.step==1 -> {
+                            // step = 1
+                            asmgen.out("""
+                lda  #${range.first}
+                sta  $varname
+                lda  #${range.last-range.first+1 and 255}
+                sta  $counterLabel
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                inc  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        range.step==-1 -> {
+                            // step = -1
+                            asmgen.out("""
+                lda  #${range.first}
+                sta  $varname
+                lda  #${range.first-range.last+1 and 255}
+                sta  $counterLabel
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                dec  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        range.step >= 2 -> {
+                            // step >= 2
+                            asmgen.out("""
+                lda  #${(range.last-range.first) / range.step + 1}
+                sta  $counterLabel
+                lda  #${range.first}
+                sta  $varname
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                lda  $varname
+                clc
+                adc  #${range.step}
+                sta  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                        else -> {
+                            // step <= -2
+                            asmgen.out("""
+                lda  #${(range.first-range.last) / range.step.absoluteValue + 1}
+                sta  $counterLabel
+                lda  #${range.first}
+                sta  $varname
+$loopLabel""")
+                            asmgen.translate(stmt.body)
+                            asmgen.out("""
+$continueLabel  dec  $counterLabel
+                beq  $endLabel
+                lda  $varname
+                sec
+                sbc  #${range.step.absoluteValue}
+                sta  $varname
+                jmp  $loopLabel
+$counterLabel   .byte  0                
+$endLabel""")
+                        }
+                    }
+                }
+            }
+            DataType.ARRAY_W, DataType.ARRAY_UW -> {
+                // loop over word range via loopvar
+                val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                when {
+                    range.step == 1 -> {
+                        // word, step = 1
+                        val lastValue = range.last+1
+                        asmgen.out("""
+                lda  #<${range.first}
+                ldy  #>${range.first}
+                sta  $varname
+                sty  $varname+1
+$loopLabel""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  inc  $varname
+                bne  +
+                inc  $varname+1
++               lda  $varname
+                cmp  #<$lastValue
+                bne  +
+                lda  $varname+1
+                cmp  #>$lastValue
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel""")
+                    }
+                    range.step == -1 -> {
+                        // word, step = 1
+                        val lastValue = range.last-1
+                        asmgen.out("""
+                lda  #<${range.first}
+                ldy  #>${range.first}
+                sta  $varname
+                sty  $varname+1
+$loopLabel""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  lda  $varname
+                bne  +
+                dec  $varname+1
++               dec  $varname
+                lda  $varname
+                cmp  #<$lastValue
+                bne  +
+                lda  $varname+1
+                cmp  #>$lastValue
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel""")
+                    }
+                    range.step >= 2 -> {
+                        // word, step >= 2
+                        TODO("for, word, step>=2")
+                    }
+                    else -> {
+                        // step <= -2
+                        TODO("for, word, step<=-2")
+                    }
+                }
+            }
+            else -> throw AssemblyError("range expression can only be byte or word")
+        }
+        asmgen.loopEndLabels.pop()
+        asmgen.loopContinueLabels.pop()
+    }
+
+}

compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt

@@ -0,0 +1,235 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.IFunctionCall
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Subroutine
+import prog8.ast.statements.SubroutineParameter
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.toHex
+
+internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
+
+    internal fun translateFunctionCall(stmt: IFunctionCall) {
+        // output the code to setup the parameters and perform the actual call
+        // does NOT output the code to deal with the result values!
+        val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
+        if(Register.X in sub.asmClobbers)
+            asmgen.out("  stx  c64.SCRATCH_ZPREGX")        // we only save X for now (required! is the eval stack pointer), screw A and Y...
+
+        val subName = asmgen.asmIdentifierName(stmt.target)
+        if(stmt.arglist.isNotEmpty()) {
+            for(arg in sub.parameters.withIndex().zip(stmt.arglist)) {
+                translateFuncArguments(arg.first, arg.second, sub)
+            }
+        }
+        asmgen.out("  jsr  $subName")
+
+        if(Register.X in sub.asmClobbers)
+            asmgen.out("  ldx  c64.SCRATCH_ZPREGX")        // restore X again
+    }
+
+    private fun translateFuncArguments(parameter: IndexedValue<SubroutineParameter>, value: Expression, sub: Subroutine) {
+        val sourceIDt = value.inferType(program)
+        if(!sourceIDt.isKnown)
+            throw AssemblyError("arg type unknown")
+        val sourceDt = sourceIDt.typeOrElse(DataType.STRUCT)
+        if(!argumentTypeCompatible(sourceDt, parameter.value.type))
+            throw AssemblyError("argument type incompatible")
+        if(sub.asmParameterRegisters.isEmpty()) {
+            // pass parameter via a variable
+            val paramVar = parameter.value
+            val scopedParamVar = (sub.scopedname+"."+paramVar.name).split(".")
+            val target = AssignTarget(null, IdentifierReference(scopedParamVar, sub.position), null, null, sub.position)
+            target.linkParents(value.parent)
+            when (value) {
+                is NumericLiteralValue -> {
+                    // optimize when the argument is a constant literal
+                    when(parameter.value.type) {
+                        in ByteDatatypes -> asmgen.assignFromByteConstant(target, value.number.toShort())
+                        in WordDatatypes -> asmgen.assignFromWordConstant(target, value.number.toInt())
+                        DataType.FLOAT -> asmgen.assignFromFloatConstant(target, value.number.toDouble())
+                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as arguments?")
+                        else -> throw AssemblyError("weird parameter datatype")
+                    }
+                }
+                is IdentifierReference -> {
+                    // optimize when the argument is a variable
+                    when (parameter.value.type) {
+                        in ByteDatatypes -> asmgen.assignFromByteVariable(target, value)
+                        in WordDatatypes -> asmgen.assignFromWordVariable(target, value)
+                        DataType.FLOAT -> asmgen.assignFromFloatVariable(target, value)
+                        in PassByReferenceDatatypes -> throw AssemblyError("can't pass string/array as arguments?")
+                        else -> throw AssemblyError("weird parameter datatype")
+                    }
+                }
+                is RegisterExpr -> {
+                    asmgen.assignFromRegister(target, value.register)
+                }
+                is DirectMemoryRead -> {
+                    when(value.addressExpression) {
+                        is NumericLiteralValue -> {
+                            val address = (value.addressExpression as NumericLiteralValue).number.toInt()
+                            asmgen.assignFromMemoryByte(target, address, null)
+                        }
+                        is IdentifierReference -> {
+                            asmgen.assignFromMemoryByte(target, null, value.addressExpression as IdentifierReference)
+                        }
+                        else -> {
+                            asmgen.translateExpression(value.addressExpression)
+                            asmgen.out("  jsr  prog8_lib.read_byte_from_address |  inx")
+                            asmgen.assignFromRegister(target, Register.A)
+                        }
+                    }
+                }
+                else -> {
+                    asmgen.translateExpression(value)
+                    asmgen.assignFromEvalResult(target)
+                }
+            }
+        } else {
+            // pass parameter via a register parameter
+            val paramRegister = sub.asmParameterRegisters[parameter.index]
+            val statusflag = paramRegister.statusflag
+            val register = paramRegister.registerOrPair
+            val stack = paramRegister.stack
+            when {
+                stack -> {
+                    // push arg onto the stack
+                    // note: argument order is reversed (first argument will be deepest on the stack)
+                    asmgen.translateExpression(value)
+                }
+                statusflag!=null -> {
+                    if (statusflag == Statusflag.Pc) {
+                        // this param needs to be set last, right before the jsr
+                        // for now, this is already enforced on the subroutine definition by the Ast Checker
+                        when(value) {
+                            is NumericLiteralValue -> {
+                                val carrySet = value.number.toInt() != 0
+                                asmgen.out(if(carrySet) "  sec" else "  clc")
+                            }
+                            is IdentifierReference -> {
+                                val sourceName = asmgen.asmIdentifierName(value)
+                                asmgen.out("""
+            lda  $sourceName
+            beq  +
+            sec  
+            bcs  ++
++           clc
++
+""")
+                            }
+                            is RegisterExpr -> {
+                                when(value.register) {
+                                    Register.A -> asmgen.out("  cmp  #0")
+                                    Register.X -> asmgen.out("  txa")
+                                    Register.Y -> asmgen.out("  tya")
+                                }
+                                asmgen.out("""
+            beq  +
+            sec
+            bcs  ++
++           clc
++
+""")
+                            }
+                            else -> {
+                                asmgen.translateExpression(value)
+                                asmgen.out("""
+            inx                        
+            lda  ${MachineDefinition.ESTACK_LO_HEX},x
+            beq  +
+            sec  
+            bcs  ++
++           clc
++
+""")
+                            }
+                        }
+                    }
+                    else throw AssemblyError("can only use Carry as status flag parameter")
+                }
+                register!=null && register.name.length==1 -> {
+                    when (value) {
+                        is NumericLiteralValue -> {
+                            val target = AssignTarget(Register.valueOf(register.name), null, null, null, sub.position)
+                            target.linkParents(value.parent)
+                            asmgen.assignFromByteConstant(target, value.number.toShort())
+                        }
+                        is IdentifierReference -> {
+                            val target = AssignTarget(Register.valueOf(register.name), null, null, null, sub.position)
+                            target.linkParents(value.parent)
+                            asmgen.assignFromByteVariable(target, value)
+                        }
+                        else -> {
+                            asmgen.translateExpression(value)
+                            when(register) {
+                                RegisterOrPair.A -> asmgen.out("  inx | lda  ${MachineDefinition.ESTACK_LO_HEX},x")
+                                RegisterOrPair.X -> throw AssemblyError("can't pop into X register - use a variable instead")
+                                RegisterOrPair.Y -> asmgen.out("  inx | ldy  ${MachineDefinition.ESTACK_LO_HEX},x")
+                                else -> throw AssemblyError("cannot assign to register pair")
+                            }
+                        }
+                    }
+                }
+                register!=null && register.name.length==2 -> {
+                    // register pair as a 16-bit value (only possible for subroutine parameters)
+                    when (value) {
+                        is NumericLiteralValue -> {
+                            // optimize when the argument is a constant literal
+                            val hex = value.number.toHex()
+                            when (register) {
+                                RegisterOrPair.AX -> asmgen.out("  lda  #<$hex  |  ldx  #>$hex")
+                                RegisterOrPair.AY -> asmgen.out("  lda  #<$hex  |  ldy  #>$hex")
+                                RegisterOrPair.XY -> asmgen.out("  ldx  #<$hex  |  ldy  #>$hex")
+                                else -> {}
+                            }
+                        }
+                        is AddressOf -> {
+                            // optimize when the argument is an address of something
+                            val sourceName = asmgen.asmIdentifierName(value.identifier)
+                            when (register) {
+                                RegisterOrPair.AX -> asmgen.out("  lda  #<$sourceName  |  ldx  #>$sourceName")
+                                RegisterOrPair.AY -> asmgen.out("  lda  #<$sourceName  |  ldy  #>$sourceName")
+                                RegisterOrPair.XY -> asmgen.out("  ldx  #<$sourceName  |  ldy  #>$sourceName")
+                                else -> {}
+                            }
+                        }
+                        is IdentifierReference -> {
+                            val sourceName = asmgen.asmIdentifierName(value)
+                            when (register) {
+                                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName  |  ldx  $sourceName+1")
+                                RegisterOrPair.AY -> asmgen.out("  lda  $sourceName  |  ldy  $sourceName+1")
+                                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName  |  ldy  $sourceName+1")
+                                else -> {}
+                            }
+                        }
+                        else -> {
+                            asmgen.translateExpression(value)
+                            if (register == RegisterOrPair.AX || register == RegisterOrPair.XY)
+                                throw AssemblyError("can't use X register here - use a variable")
+                            else if (register == RegisterOrPair.AY)
+                                asmgen.out("  inx |  lda  ${MachineDefinition.ESTACK_LO_HEX},x  |  ldy  ${MachineDefinition.ESTACK_HI_HEX},x")
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun argumentTypeCompatible(argType: DataType, paramType: DataType): Boolean {
+        if(argType isAssignableTo paramType)
+            return true
+
+        // we have a special rule for some types.
+        // strings are assignable to UWORD, for example, and vice versa
+        if(argType in StringDatatypes && paramType==DataType.UWORD)
+            return true
+        if(argType==DataType.UWORD && paramType in StringDatatypes)
+            return true
+
+        return false
+    }
+}

compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt

@@ -0,0 +1,149 @@
+package prog8.compiler.target.c64.codegen
+
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.expressions.RegisterExpr
+import prog8.ast.statements.PostIncrDecr
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.toHex
+
+internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {
+    internal fun translate(stmt: PostIncrDecr) {
+        val incr = stmt.operator=="++"
+        val targetIdent = stmt.target.identifier
+        val targetMemory = stmt.target.memoryAddress
+        val targetArrayIdx = stmt.target.arrayindexed
+        val targetRegister = stmt.target.register
+        when {
+            targetRegister!=null -> {
+                when(targetRegister) {
+                    Register.A -> {
+                        if(incr)
+                            asmgen.out("  clc |  adc  #1 ")
+                        else
+                            asmgen.out("  sec |  sbc  #1 ")
+                    }
+                    Register.X -> {
+                        if(incr) asmgen.out("  inx") else asmgen.out("  dex")
+                    }
+                    Register.Y -> {
+                        if(incr) asmgen.out("  iny") else asmgen.out("  dey")
+                    }
+                }
+            }
+            targetIdent!=null -> {
+                val what = asmgen.asmIdentifierName(targetIdent)
+                val dt = stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)
+                when (dt) {
+                    in ByteDatatypes -> asmgen.out(if (incr) "  inc  $what" else "  dec  $what")
+                    in WordDatatypes -> {
+                        if(incr)
+                            asmgen.out(" inc  $what |  bne  + |  inc  $what+1 |+")
+                        else
+                            asmgen.out("""
+        lda  $what
+        bne  +
+        dec  $what+1
++       dec  $what 
+""")
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.out("  lda  #<$what |  ldy  #>$what")
+                        asmgen.out(if(incr) "  jsr  c64flt.inc_var_f" else "  jsr  c64flt.dec_var_f")
+                    }
+                    else -> throw AssemblyError("need numeric type")
+                }
+            }
+            targetMemory!=null -> {
+                val addressExpr = targetMemory.addressExpression
+                when (addressExpr) {
+                    is NumericLiteralValue -> {
+                        val what = addressExpr.number.toHex()
+                        asmgen.out(if(incr) "  inc  $what" else "  dec  $what")
+                    }
+                    is IdentifierReference -> {
+                        val what = asmgen.asmIdentifierName(addressExpr)
+                        asmgen.out(if(incr) "  inc  $what" else "  dec  $what")
+                    }
+                    else -> throw AssemblyError("weird target type $targetMemory")
+                }
+            }
+            targetArrayIdx!=null -> {
+                val index = targetArrayIdx.arrayspec.index
+                val what = asmgen.asmIdentifierName(targetArrayIdx.identifier)
+                val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
+                val elementDt = ArrayElementTypes.getValue(arrayDt)
+                when(index) {
+                    is NumericLiteralValue -> {
+                        val indexValue = index.number.toInt() * elementDt.memorySize()
+                        when(elementDt) {
+                            in ByteDatatypes -> asmgen.out(if (incr) "  inc  $what+$indexValue" else "  dec  $what+$indexValue")
+                            in WordDatatypes -> {
+                                if(incr)
+                                    asmgen.out(" inc  $what+$indexValue |  bne  + |  inc  $what+$indexValue+1 |+")
+                                else
+                                    asmgen.out("""
+        lda  $what+$indexValue
+        bne  +
+        dec  $what+$indexValue+1
++       dec  $what+$indexValue 
+""")
+                            }
+                            DataType.FLOAT -> {
+                                asmgen.out("  lda  #<$what+$indexValue |  ldy  #>$what+$indexValue")
+                                asmgen.out(if(incr) "  jsr  c64flt.inc_var_f" else "  jsr  c64flt.dec_var_f")
+                            }
+                            else -> throw AssemblyError("need numeric type")
+                        }
+                    }
+                    is RegisterExpr -> {
+                        // TODO optimize common cases
+                        asmgen.translateArrayIndexIntoA(targetArrayIdx)
+                        incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
+                    }
+                    is IdentifierReference -> {
+                        // TODO optimize common cases
+                        asmgen.translateArrayIndexIntoA(targetArrayIdx)
+                        incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
+                    }
+                    else -> {
+                        // TODO optimize common cases
+                        asmgen.translateArrayIndexIntoA(targetArrayIdx)
+                        incrDecrArrayvalueWithIndexA(incr, arrayDt, what)
+                    }
+                }
+            }
+            else -> throw AssemblyError("weird target type ${stmt.target}")
+        }
+    }
+
+    private fun incrDecrArrayvalueWithIndexA(incr: Boolean, arrayDt: DataType, arrayVarName: String) {
+        asmgen.out("  stx  ${MachineDefinition.C64Zeropage.SCRATCH_REG_X} |  tax")
+        when(arrayDt) {
+            DataType.STR, DataType.STR_S,
+            DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                asmgen.out(if(incr) "  inc  $arrayVarName,x" else "  dec  $arrayVarName,x")
+            }
+            DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                if(incr)
+                    asmgen.out(" inc  $arrayVarName,x |  bne  + |  inc  $arrayVarName+1,x |+")
+                else
+                    asmgen.out("""
+        lda  $arrayVarName,x
+        bne  +
+        dec  $arrayVarName+1,x
++       dec  $arrayVarName 
+""")
+            }
+            DataType.ARRAY_F -> {
+                asmgen.out("  lda  #<$arrayVarName |  ldy  #>$arrayVarName")
+                asmgen.out(if(incr) "  jsr  c64flt.inc_indexed_var_f" else "  jsr  c64flt.dec_indexed_var_f")
+            }
+            else -> throw AssemblyError("weird array dt")
+        }
+        asmgen.out("  ldx  ${MachineDefinition.C64Zeropage.SCRATCH_REG_X}")
+    }
+
+}

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -27,13 +27,16 @@ val BuiltinFunctions = mapOf(
     "ror2"        to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
     "lsl"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
     "lsr"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
+    "sort"        to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
+    "reverse"     to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
         // these few have a return value depending on the argument(s):
-    "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
+    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMax) },    // type depends on args
+    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMin) },    // type depends on args
+    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // 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:
+    "sgn"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
     "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 ),
@@ -52,12 +55,11 @@ val BuiltinFunctions = mapOf(
     "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) },
+    "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
+    "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
     "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(
@@ -75,18 +77,20 @@ val BuiltinFunctions = mapOf(
     "read_flags"  to FunctionSignature(false, emptyList(), DataType.UBYTE),
     "swap"        to FunctionSignature(false, listOf(BuiltinFunctionParam("first", NumericDatatypes), BuiltinFunctionParam("second", NumericDatatypes)), null),
     "memcopy"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("from", IterableDatatypes + setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("to", IterableDatatypes + setOf(DataType.UWORD)),
+                                                        BuiltinFunctionParam("from", IterableDatatypes + DataType.UWORD),
+                                                        BuiltinFunctionParam("to", IterableDatatypes + DataType.UWORD),
                                                         BuiltinFunctionParam("numbytes", setOf(DataType.UBYTE))), null),
     "memset"      to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + setOf(DataType.UWORD)),
+                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
                                                         BuiltinFunctionParam("numbytes", setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("bytevalue", ByteDatatypes)), null),
     "memsetw"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + setOf(DataType.UWORD)),
+                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
                                                         BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
     "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", StringDatatypes)), DataType.UBYTE, ::builtinStrlen),
+
+    // TODO clean up these vm-specific functions
     "vm_write_memchr"  to FunctionSignature(false, listOf(BuiltinFunctionParam("address", setOf(DataType.UWORD))), null),
     "vm_write_memstr"  to FunctionSignature(false, listOf(BuiltinFunctionParam("address", setOf(DataType.UWORD))), null),
     "vm_write_num"     to FunctionSignature(false, listOf(BuiltinFunctionParam("number", NumericDatatypes)), null),
@@ -112,26 +116,40 @@ val BuiltinFunctions = mapOf(
                                                         null)
 )
 
+fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
 
-fun builtinFunctionReturnType(function: String, args: List<Expression>, program: Program): DataType? {
+fun builtinMin(array: List<Number>): Number = array.minBy { it.toDouble() }!!
+
+fun builtinSum(array: List<Number>): Number = array.sumByDouble { it.toDouble() }
+
+fun builtinAny(array: List<Number>): Number = if(array.any { it.toDouble()!=0.0 }) 1 else 0
+
+fun builtinAll(array: List<Number>): Number = if(array.all { it.toDouble()!=0.0 }) 1 else 0
+
+
+fun builtinFunctionReturnType(function: String, args: List<Expression>, program: Program): InferredTypes.InferredType {
 
     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
-                return DataType.UBYTE
+        if(arglist is ArrayLiteralValue) {
+            val dt = arglist.value.map {it.inferType(program).typeOrElse(DataType.STRUCT)}.toSet()
+            if(dt.any { it !in NumericDatatypes }) {
+                throw FatalAstException("fuction $function only accepts array of numeric values")
             }
+            if(DataType.FLOAT in dt) return DataType.FLOAT
+            if(DataType.UWORD in dt) return DataType.UWORD
+            if(DataType.WORD in dt) return DataType.WORD
+            if(DataType.BYTE in dt) return DataType.BYTE
+            return DataType.UBYTE
         }
         if(arglist is IdentifierReference) {
-            return when(val dt = arglist.inferType(program)) {
-                in NumericDatatypes -> dt!!
-                in StringDatatypes -> dt!!
-                in ArrayDatatypes -> ArrayElementTypes.getValue(dt!!)
+            val idt = arglist.inferType(program)
+            if(!idt.isKnown)
+                throw FatalAstException("couldn't determine type of iterable $arglist")
+            val dt = idt.typeOrElse(DataType.STRUCT)
+            return when(dt) {
+                in NumericDatatypes -> dt
+                in StringDatatypes -> dt
+                in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
                 else -> throw FatalAstException("function '$function' requires one argument which is an iterable")
             }
         }
@@ -140,49 +158,48 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
 
     val func = BuiltinFunctions.getValue(function)
     if(func.returntype!=null)
-        return func.returntype
+        return InferredTypes.knownFor(func.returntype)
     // function has return values, but the return type depends on the arguments
 
     return when (function) {
         "abs" -> {
-            when(val dt = args.single().inferType(program)) {
-                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.typeOrElse(DataType.STRUCT) in NumericDatatypes)
+                return dt
+            else
+                throw FatalAstException("weird datatype passed to abs $dt")
         }
         "max", "min" -> {
             when(val dt = datatypeFromIterableArg(args.single())) {
-                in NumericDatatypes -> dt
-                in StringDatatypes -> DataType.UBYTE
-                in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
-                else -> null
+                in NumericDatatypes -> InferredTypes.knownFor(dt)
+                in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE)
+                in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(dt))
+                else -> InferredTypes.unknown()
             }
         }
         "sum" -> {
             when(datatypeFromIterableArg(args.single())) {
-                DataType.UBYTE, DataType.UWORD -> DataType.UWORD
-                DataType.BYTE, DataType.WORD -> DataType.WORD
-                DataType.FLOAT -> DataType.FLOAT
-                DataType.ARRAY_UB, DataType.ARRAY_UW -> DataType.UWORD
-                DataType.ARRAY_B, DataType.ARRAY_W -> DataType.WORD
-                DataType.ARRAY_F -> DataType.FLOAT
-                in StringDatatypes -> DataType.UWORD
-                else -> null
+                DataType.UBYTE, DataType.UWORD -> InferredTypes.knownFor(DataType.UWORD)
+                DataType.BYTE, DataType.WORD -> InferredTypes.knownFor(DataType.WORD)
+                DataType.FLOAT -> InferredTypes.knownFor(DataType.FLOAT)
+                DataType.ARRAY_UB, DataType.ARRAY_UW -> InferredTypes.knownFor(DataType.UWORD)
+                DataType.ARRAY_B, DataType.ARRAY_W -> InferredTypes.knownFor(DataType.WORD)
+                DataType.ARRAY_F -> InferredTypes.knownFor(DataType.FLOAT)
+                in StringDatatypes -> InferredTypes.knownFor(DataType.UWORD)
+                else -> InferredTypes.unknown()
             }
         }
         "len" -> {
             // a length can be >255 so in that case, the result is an UWORD instead of an UBYTE
             // but to avoid a lot of code duplication we simply assume UWORD in all cases for now
-            return DataType.UWORD
+            return InferredTypes.knownFor(DataType.UWORD)
         }
-        else -> return null
+        else -> return InferredTypes.unknown()
     }
 }
 
 
-class NotConstArgumentException: AstException("not a const argument to a built-in function")
+class NotConstArgumentException: AstException("not a const argument to a built-in function")        // TODO: ugly, remove throwing exceptions for control flow
 
 
 private fun oneDoubleArg(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Number): NumericLiteralValue {
@@ -212,12 +229,16 @@ private fun oneIntArgOutputInt(args: List<Expression>, position: Position, progr
     return numericLiteral(function(integer).toInt(), args[0].position)
 }
 
-private fun collectionArgNeverConst(args: List<Expression>, position: Position): NumericLiteralValue {
+private fun collectionArg(args: List<Expression>, position: Position, program: Program, function: (arg: List<Number>)->Number): NumericLiteralValue {
     if(args.size!=1)
         throw SyntaxError("builtin function requires one non-scalar argument", position)
 
-    // max/min/sum etc only work on arrays and these are never considered to be const for these functions
-    throw NotConstArgumentException()
+    val array= args[0] as? ArrayLiteralValue ?: throw NotConstArgumentException()
+    val constElements = array.value.map{it.constValue(program)?.number}
+    if(constElements.contains(null))
+        throw NotConstArgumentException()
+
+    return NumericLiteralValue.optimalNumeric(function(constElements.mapNotNull { it }), args[0].position)
 }
 
 private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
@@ -255,6 +276,8 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
     var arraySize = directMemVar?.arraysize?.size()
     if(arraySize != null)
         return NumericLiteralValue.optimalInteger(arraySize, position)
+    if(args[0] is ArrayLiteralValue)
+        return NumericLiteralValue.optimalInteger((args[0] as ArrayLiteralValue).value.size, 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)!!
@@ -273,10 +296,10 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
             NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
         in StringDatatypes -> {
-            val refLv = target.value as ReferenceLiteralValue
-            if(refLv.str!!.length>255)
+            val refLv = target.value as StringLiteralValue
+            if(refLv.value.length>255)
                 throw CompilerException("string length exceeds byte limit ${refLv.position}")
-            NumericLiteralValue.optimalInteger(refLv.str.length, args[0].position)
+            NumericLiteralValue.optimalInteger(refLv.value.length, args[0].position)
         }
         in NumericDatatypes -> throw SyntaxError("len of weird argument ${args[0]}", position)
         else -> throw CompilerException("weird datatype")
@@ -357,6 +380,13 @@ private fun builtinCos16u(args: List<Expression>, position: Position, program: P
     return NumericLiteralValue(DataType.UWORD, (32768.0 + 32767.5 * cos(rad)).toInt(), position)
 }
 
+private fun builtinSgn(args: List<Expression>, position: Position, program: Program): NumericLiteralValue {
+    if (args.size != 1)
+        throw SyntaxError("sgn requires one argument", position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    return NumericLiteralValue(DataType.BYTE, constval.number.toDouble().sign.toShort(), position)
+}
+
 private fun numericLiteral(value: Number, position: Position): NumericLiteralValue {
     val floatNum=value.toDouble()
     val tweakedValue: Number =

compiler/src/prog8/optimizer/CallGraph.kt

@@ -111,7 +111,8 @@ class CallGraph(private val program: Program): IAstVisitor {
     override fun visit(subroutine: Subroutine) {
         val alwaysKeepSubroutines = setOf(
                 Pair("main", "start"),
-                Pair("irq", "irq")
+                Pair("irq", "irq"),
+                Pair("prog8_lib", "init_system")
         )
 
         if(Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -5,11 +5,12 @@ 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.HeapValues
-import prog8.compiler.IntegerOrAddressOf
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
+import prog8.compiler.target.c64.codegen.AssemblyError
+import prog8.functions.BuiltinFunctions
 import kotlin.math.floor
 
 
@@ -35,16 +36,12 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         }
 
         if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
-            val refLv = decl.value as? ReferenceLiteralValue
-            if(refLv!=null && refLv.isArray && refLv.heapId!=null)
-                fixupArrayTypeOnHeap(decl, refLv)
-
             if(decl.isArray){
-                // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
                 if(decl.arraysize==null) {
-                    val arrayval = (decl.value as? ReferenceLiteralValue)?.array
+                    // for arrays that have no size specifier (or a non-constant one) attempt to deduce the size
+                    val arrayval = decl.value as? ArrayLiteralValue
                     if(arrayval!=null) {
-                        decl.arraysize = ArrayIndex(NumericLiteralValue.optimalInteger(arrayval.size, decl.position), decl.position)
+                        decl.arraysize = ArrayIndex(NumericLiteralValue.optimalInteger(arrayval.value.size, decl.position), decl.position)
                         optimizationsDone++
                     }
                 }
@@ -78,21 +75,21 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                     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())
                             errors.add(ExpressionError("range expression size doesn't match declared array size", decl.value?.position!!))
                         val constRange = rangeExpr.toConstantIntegerRange()
                         if(constRange!=null) {
-                            val eltType = rangeExpr.inferType(program)!!
+                            val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
                             if(eltType in ByteDatatypes) {
-                                decl.value = ReferenceLiteralValue(decl.datatype,
-                                        array = constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }
-                                                .toTypedArray(), position = decl.value!!.position)
+                                decl.value = ArrayLiteralValue(decl.datatype,
+                                        constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
                             } else {
-                                decl.value = ReferenceLiteralValue(decl.datatype,
-                                        array = constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }
-                                                .toTypedArray(), position = decl.value!!.position)
+                                decl.value = ArrayLiteralValue(decl.datatype,
+                                        constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
+                                        position = decl.value!!.position)
                             }
                             decl.value!!.linkParents(decl)
                             optimizationsDone++
@@ -124,8 +121,12 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                             }
                             else -> {}
                         }
-                        val heapId = program.heap.addIntegerArray(decl.datatype, Array(size) { IntegerOrAddressOf(fillvalue, null) })
-                        decl.value = ReferenceLiteralValue(decl.datatype, initHeapId = heapId, position = numericLv.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 = ArrayLiteralValue(decl.datatype, array, position = numericLv.position)
+                        refValue.addToHeap(program.heap)
+                        decl.value = refValue
+                        refValue.parent=decl
                         optimizationsDone++
                         return super.visit(decl)
                     }
@@ -142,8 +143,12 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         if (fillvalue < FLOAT_MAX_NEGATIVE || fillvalue > FLOAT_MAX_POSITIVE)
                             errors.add(ExpressionError("float value overflow", litval.position))
                         else {
-                            val heapId = program.heap.addDoublesArray(DoubleArray(size) { fillvalue })
-                            decl.value = ReferenceLiteralValue(DataType.ARRAY_F, initHeapId = heapId, position = litval.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 = ArrayLiteralValue(DataType.ARRAY_F, array, position = litval.position)
+                            refValue.addToHeap(program.heap)
+                            decl.value = refValue
+                            refValue.parent=decl
                             optimizationsDone++
                             return super.visit(decl)
                         }
@@ -158,40 +163,19 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         return super.visit(decl)
     }
 
-    private fun fixupArrayTypeOnHeap(decl: VarDecl, litval: ReferenceLiteralValue) {
-        // 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 = program.heap.get(heapId)
-        when(decl.datatype) {
-            DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                if(array.array!=null) {
-                    program.heap.update(heapId, HeapValues.HeapValue(decl.datatype, null, array.array, null))
-                    decl.value = ReferenceLiteralValue(decl.datatype, initHeapId = heapId, position = litval.position)
-                }
-            }
-            DataType.ARRAY_F -> {
-                if(array.array!=null) {
-                    // convert a non-float array to floats
-                    val doubleArray = array.array.map { it.integer!!.toDouble() }.toDoubleArray()
-                    program.heap.update(heapId, HeapValues.HeapValue(DataType.ARRAY_F, null, null, doubleArray))
-                    decl.value = ReferenceLiteralValue(decl.datatype, initHeapId = heapId, position = litval.position)
-                }
-            }
-            DataType.STRUCT -> {
-                // leave it alone for structs.
-            }
-            else -> throw FatalAstException("invalid array vardecl type ${decl.datatype}")
-        }
-    }
-
     /**
      * replace identifiers that refer to const value, with the value itself (if it's a simple type)
      */
     override fun visit(identifier: IdentifierReference): Expression {
+        // don't replace when it's an assignment target or loop variable
+        if(identifier.parent is AssignTarget)
+            return identifier
+        var forloop = identifier.parent as? ForLoop
+        if(forloop==null)
+            forloop = identifier.parent.parent as? ForLoop
+        if(forloop!=null && identifier===forloop.loopVar)
+            return identifier
+
         return try {
             val cval = identifier.constValue(program) ?: return identifier
             return when {
@@ -200,7 +184,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                     copy.parent = identifier.parent
                     copy
                 }
-                cval.type in PassByReferenceDatatypes -> TODO("ref type $identifier")
+                cval.type in PassByReferenceDatatypes -> throw AssemblyError("pass-by-reference type should not be considered a constant")
                 else -> identifier
             }
         } catch (ax: AstException) {
@@ -210,9 +194,9 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     }
 
     override fun visit(functionCall: FunctionCall): Expression {
+        super.visit(functionCall)
+        typeCastConstArguments(functionCall)
         return try {
-            super.visit(functionCall)
-            typeCastConstArguments(functionCall)
             functionCall.constValue(program) ?: functionCall
         } catch (ax: AstException) {
             addError(ax)
@@ -227,6 +211,23 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     }
 
     private fun typeCastConstArguments(functionCall: IFunctionCall) {
+        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())
+                        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
@@ -235,10 +236,8 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                 val argConst = arg.first.value.constValue(program)
                 if(argConst!=null && argConst.type!=expectedDt) {
                     val convertedValue = argConst.cast(expectedDt)
-                    if(convertedValue!=null) {
-                        functionCall.arglist[arg.first.index] = convertedValue
-                        optimizationsDone++
-                    }
+                    functionCall.arglist[arg.first.index] = convertedValue
+                    optimizationsDone++
                 }
             }
         }
@@ -259,14 +258,16 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
      */
     override fun visit(expr: PrefixExpression): Expression {
         return try {
-            super.visit(expr)
+            val prefixExpr=super.visit(expr)
+            if(prefixExpr !is PrefixExpression)
+                return prefixExpr
 
-            val subexpr = expr.expression
+            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 {
+                    prefixExpr.operator == "+" -> subexpr
+                    prefixExpr.operator == "-" -> when {
                         subexpr.type in IntegerDatatypes -> {
                             optimizationsDone++
                             NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position)
@@ -277,21 +278,21 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         }
                         else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
                     }
-                    expr.operator == "~" -> when {
+                    prefixExpr.operator == "~" -> when {
                         subexpr.type in IntegerDatatypes -> {
                             optimizationsDone++
                             NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position)
                         }
                         else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
                     }
-                    expr.operator == "not" -> {
+                    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
@@ -319,8 +320,9 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         return try {
             super.visit(expr)
 
-            if(expr.left is ReferenceLiteralValue || expr.right is ReferenceLiteralValue)
-                TODO("binexpr with reference litval")
+            if(expr.left is StringLiteralValue || expr.left is ArrayLiteralValue
+                    || expr.right is StringLiteralValue || expr.right is ArrayLiteralValue)
+                throw FatalAstException("binexpr with reference litval instead of numeric")
 
             val leftconst = expr.left.constValue(program)
             val rightconst = expr.right.constValue(program)
@@ -364,7 +366,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                                        subleftIsConst: Boolean,
                                        subrightIsConst: Boolean): Expression
     {
-        // @todo this implements only a small set of possible reorderings for now
+        // todo: this implements only a small set of possible reorderings at this time
         if(expr.operator==subExpr.operator) {
             // both operators are the isSameAs.
             // If + or *,  we can simply swap the const of expr and Var in subexpr.
@@ -552,14 +554,16 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     override fun visit(forLoop: ForLoop): Statement {
 
         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: Expression =
-                        if (stepLiteral != null) (stepLiteral.cast(targetDt) ?: stepLiteral) else range.step
-                return RangeExpr(newFrom, newTo, newStep, range.position)
+            val newFrom: NumericLiteralValue
+            val newTo: NumericLiteralValue
+            try {
+                newFrom = rangeFrom.cast(targetDt)
+                newTo = rangeTo.cast(targetDt)
+            } catch (x: ExpressionError) {
+                return range
             }
-            return range
+            val newStep: Expression = stepLiteral?.cast(targetDt) ?: range.step
+            return RangeExpr(newFrom, newTo, newStep, range.position)
         }
 
         // adjust the datatype of a range expression in for loops to the loop variable.
@@ -603,69 +607,20 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         return resultStmt
     }
 
-    override fun visit(refLiteral: ReferenceLiteralValue): Expression {
-        val litval = super.visit(refLiteral)
-        if(litval is ReferenceLiteralValue) {
-            if (litval.isString) {
-                // intern the string; move it into the heap
-                if (litval.str!!.length !in 1..255)
-                    addError(ExpressionError("string literal length must be between 1 and 255", litval.position))
-                else {
-                    litval.addToHeap(program.heap)  // TODO: we don't know the actual string type yet, STR != STR_S etc...
-                }
-            } else if (litval.isArray) {
-                // first, adjust the array datatype
-                val litval2 = adjustArrayValDatatype(litval)
-                litval2.addToHeap(program.heap)
-                return litval2
+    override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
+        val array = super.visit(arrayLiteral)
+        if(array is ArrayLiteralValue) {
+            if(array.heapId==null)
+                array.addToHeap(program.heap)
+            val vardecl = array.parent as? VarDecl
+            return if (vardecl!=null) {
+                fixupArrayDatatype(array, vardecl, program)
+            } else {
+                // it's not an array associated with a vardecl, attempt to guess the data type from the array values
+                fixupArrayDatatype(array, program)
             }
         }
-        return litval
-    }
-
-    private fun adjustArrayValDatatype(litval: ReferenceLiteralValue): ReferenceLiteralValue {
-        if(litval.array==null) {
-            if(litval.heapId!=null)
-                return litval       // thing is already on the heap, assume it's the right type
-            throw FatalAstException("missing array value")
-        }
-
-        val typesInArray = litval.array.mapNotNull { it.inferType(program) }.toSet()
-        val arrayDt =
-                when {
-                    litval.array.any { it is AddressOf } -> DataType.ARRAY_UW
-                    DataType.FLOAT in typesInArray -> DataType.ARRAY_F
-                    DataType.WORD in typesInArray -> DataType.ARRAY_W
-                    else -> {
-                        val allElementsAreConstantOrAddressOf = litval.array.fold(true) { c, expr-> c and (expr is NumericLiteralValue|| expr is AddressOf)}
-                        if(!allElementsAreConstantOrAddressOf) {
-                            addError(ExpressionError("array literal can only consist of constant primitive numerical values or memory pointers", litval.position))
-                            return litval
-                        } else {
-                            val integerArray = litval.array.map { it.constValue(program)!!.number.toInt() }
-                            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
-                            }
-                        }
-                    }
-                }
-
-        if(arrayDt!=litval.type) {
-            return ReferenceLiteralValue(arrayDt, array = litval.array, position = litval.position)
-        }
-        return litval
+        return array
     }
 
     override fun visit(assignment: Assignment): Statement {
@@ -673,7 +628,10 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         val lv = assignment.value as? NumericLiteralValue
         if(lv!=null) {
             // see if we can promote/convert a literal value to the required datatype
-            when(assignment.target.inferType(program, assignment)) {
+            val idt = assignment.target.inferType(program, assignment)
+            if(!idt.isKnown)
+                return assignment
+            when(idt.typeOrElse(DataType.STRUCT)) {
                 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)

compiler/src/prog8/optimizer/Extensions.kt

@@ -27,8 +27,8 @@ internal fun Program.constantFold() {
 }
 
 
-internal fun Program.optimizeStatements(optimizeInlining: Boolean): Int {
-    val optimizer = StatementOptimizer(this, optimizeInlining)
+internal fun Program.optimizeStatements(): Int {
+    val optimizer = StatementOptimizer(this)
     optimizer.visit(this)
     modules.forEach { it.linkParents(this.namespace) }   // re-link in final configuration
 

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -1,16 +1,14 @@
 package prog8.optimizer
 
 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.base.*
 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
+import kotlin.math.pow
 
 /*
     todo advanced expression optimization: common (sub) expression elimination (turn common expressions into single subroutine call + introduce variable to hold it)
@@ -43,7 +41,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
         val literal = tc.expression as? NumericLiteralValue
         if(literal!=null) {
             val newLiteral = literal.cast(tc.type)
-            if(newLiteral!=null && newLiteral!==literal) {
+            if(newLiteral!==literal) {
                 optimizationsDone++
                 return newLiteral
             }
@@ -136,9 +134,14 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
         val constTrue = NumericLiteralValue.fromBoolean(true, expr.position)
         val constFalse = NumericLiteralValue.fromBoolean(false, expr.position)
 
-        val leftDt = expr.left.inferType(program)
-        val rightDt = expr.right.inferType(program)
-        if (leftDt != null && rightDt != null && leftDt != rightDt) {
+        val leftIDt = expr.left.inferType(program)
+        val rightIDt = expr.right.inferType(program)
+        if(!leftIDt.isKnown || !rightIDt.isKnown)
+            throw FatalAstException("can't determine datatype of both expression operands $expr")
+
+        val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
+        val rightDt = rightIDt.typeOrElse(DataType.STRUCT)
+        if (leftDt != rightDt) {
             // try to convert a datatype into the other (where ddd
             if (adjustDatatypes(expr, leftVal, leftDt, rightVal, rightDt)) {
                 optimizationsDone++
@@ -226,7 +229,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
                     val x = expr.right
                     val y = determineY(x, leftBinExpr)
                     if(y!=null) {
-                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue(leftDt!!, 1, y.position), y.position)
+                        val yPlus1 = BinaryExpression(y, "+", NumericLiteralValue(leftDt, 1, y.position), y.position)
                         return BinaryExpression(x, "*", yPlus1, x.position)
                     }
                 } else {
@@ -235,7 +238,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
                     val x = expr.right
                     val y = determineY(x, leftBinExpr)
                     if(y!=null) {
-                        val yMinus1 = BinaryExpression(y, "-", NumericLiteralValue(leftDt!!, 1, y.position), y.position)
+                        val yMinus1 = BinaryExpression(y, "-", NumericLiteralValue(leftDt, 1, y.position), y.position)
                         return BinaryExpression(x, "*", yMinus1, x.position)
                     }
                 }
@@ -338,6 +341,8 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
             "-" -> return optimizeSub(expr, leftVal, rightVal)
             "**" -> return optimizePower(expr, leftVal, rightVal)
             "%" -> return optimizeRemainder(expr, leftVal, rightVal)
+            ">>" -> return optimizeShiftRight(expr, rightVal)
+            "<<" -> return optimizeShiftLeft(expr, rightVal)
         }
         return expr
     }
@@ -590,7 +595,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
             "%" -> {
                 if (cv == 1.0) {
                     optimizationsDone++
-                    return NumericLiteralValue(expr.inferType(program)!!, 0, expr.position)
+                    return NumericLiteralValue(expr.inferType(program).typeOrElse(DataType.STRUCT), 0, expr.position)
                 } else if (cv == 2.0) {
                     optimizationsDone++
                     expr.operator = "&"
@@ -603,17 +608,24 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
 
     }
 
+    private val powersOfTwo = (1 .. 16).map { (2.0).pow(it) }.toSet()
+    private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()
+
     private fun optimizeDivision(expr: BinaryExpression, leftVal: NumericLiteralValue?, rightVal: NumericLiteralValue?): Expression {
         if(leftVal==null && rightVal==null)
             return expr
 
-        // cannot shuffle assiciativity with division!
+        // TODO fix bug in this routine!
 
+        // cannot shuffle assiciativity with division!
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize
             val rightConst: NumericLiteralValue = rightVal
             val cv = rightConst.number.toDouble()
-            val leftDt = expr.left.inferType(program)
+            val leftIDt = expr.left.inferType(program)
+            if(!leftIDt.isKnown)
+                return expr
+            val leftDt = leftIDt.typeOrElse(DataType.STRUCT)
             when(cv) {
                 -1.0 -> {
                     //  '/' -> -left
@@ -629,7 +641,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
                         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 -> {
+                in powersOfTwo -> {
                     if(leftDt in IntegerDatatypes) {
                         // divided by a power of two => shift right
                         optimizationsDone++
@@ -637,7 +649,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
                         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 -> {
+                in negativePowersOfTwo -> {
                     if(leftDt in IntegerDatatypes) {
                         // divided by a negative power of two => negate, then shift right
                         optimizationsDone++
@@ -700,16 +712,16 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
                     optimizationsDone++
                     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.inferType(program) in IntegerDatatypes) {
+                in powersOfTwo -> {
+                    if(leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
                         // times a power of two => shift left
                         optimizationsDone++
                         val numshifts = log2(cv).toInt()
                         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.inferType(program) in IntegerDatatypes) {
+                in negativePowersOfTwo -> {
+                    if(leftValue.inferType(program).typeOrElse(DataType.STRUCT) in IntegerDatatypes) {
                         // times a negative power of two => negate, then shift left
                         optimizationsDone++
                         val numshifts = log2(-cv).toInt()
@@ -722,4 +734,97 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
 
         return expr
     }
+
+    private fun optimizeShiftLeft(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression {
+        if(amountLv==null)
+            return expr
+
+        val amount=amountLv.number.toInt()
+        if(amount==0) {
+            optimizationsDone++
+            return expr.left
+        }
+        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
+        when(targetDt) {
+            DataType.UBYTE, DataType.BYTE -> {
+                if(amount>=8) {
+                    optimizationsDone++
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                }
+            }
+            DataType.UWORD, DataType.WORD -> {
+                if(amount>=16) {
+                    optimizationsDone++
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                }
+                else if(amount>=8) {
+                    optimizationsDone++
+                    val lsb=TypecastExpression(expr.left, DataType.UBYTE, true, expr.position)
+                    if(amount==8) {
+                        return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), lsb), expr.position)
+                    }
+                    val shifted = BinaryExpression(lsb, "<<", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
+                    return FunctionCall(IdentifierReference(listOf("mkword"), expr.position), mutableListOf(NumericLiteralValue.optimalInteger(0, expr.position), shifted), expr.position)
+                }
+            }
+            else -> {}
+        }
+        return expr
+    }
+
+    private fun optimizeShiftRight(expr: BinaryExpression, amountLv: NumericLiteralValue?): Expression {
+        if(amountLv==null)
+            return expr
+
+        val amount=amountLv.number.toInt()
+        if(amount==0) {
+            optimizationsDone++
+            return expr.left
+        }
+        val targetDt = expr.left.inferType(program).typeOrElse(DataType.STRUCT)
+        when(targetDt) {
+            DataType.UBYTE -> {
+                if(amount>=8) {
+                    optimizationsDone++
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                }
+            }
+            DataType.BYTE -> {
+                if(amount>8) {
+                    expr.right = NumericLiteralValue.optimalInteger(8, expr.right.position)
+                    return expr
+                }
+            }
+            DataType.UWORD -> {
+                if(amount>=16) {
+                    optimizationsDone++
+                    return NumericLiteralValue.optimalInteger(0, expr.position)
+                }
+                else if(amount>=8) {
+                    optimizationsDone++
+                    val msb=FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
+                    if(amount==8)
+                        return msb
+                    return BinaryExpression(msb, ">>", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
+                }
+            }
+            DataType.WORD -> {
+                if(amount>16) {
+                    expr.right = NumericLiteralValue.optimalInteger(16, expr.right.position)
+                    return expr
+                } else if(amount>=8) {
+                    optimizationsDone++
+                    val msbAsByte = TypecastExpression(
+                            FunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position),
+                            DataType.BYTE,
+                            true, expr.position)
+                    if(amount==8)
+                        return msbAsByte
+                    return BinaryExpression(msbAsByte, ">>", NumericLiteralValue.optimalInteger(amount-8, expr.position), expr.position)
+                }
+            }
+            else -> {}
+        }
+        return expr
+    }
 }

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -1,102 +1,38 @@
 package prog8.optimizer
 
-import prog8.ast.*
+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.processing.IAstModifyingVisitor
 import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
 import prog8.compiler.target.c64.Petscii
+import prog8.compiler.target.c64.codegen.AssemblyError
 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
+    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
+    TODO: proper inlining of small subroutines (correctly renaming/relocating all variables in them and refs to those as well, or restrict to subs without variables?)
 */
 
 
-internal class StatementOptimizer(private val program: Program, private val optimizeInlining: Boolean) : IAstModifyingVisitor {
+internal class StatementOptimizer(private val program: Program) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
         private set
 
     private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
     private val callgraph = CallGraph(program)
 
-    companion object {
-        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>()
@@ -170,18 +106,6 @@ internal class StatementOptimizer(private val program: Program, private val opti
             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++
@@ -241,8 +165,6 @@ internal class StatementOptimizer(private val program: Program, private val opti
         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 NumericLiteralValue)
-                throw AstException("string argument should be on heap already")
             val stringVar = functionCallStatement.arglist.single() as? IdentifierReference
             if(stringVar!=null) {
                 val heapId = stringVar.heapId(program.namespace)
@@ -379,10 +301,10 @@ internal class StatementOptimizer(private val program: Program, private val opti
                 printWarning("condition is always true", whileLoop.position)
                 if(hasContinueOrBreak(whileLoop.body))
                     return whileLoop
-                val label = Label("__back", whileLoop.condition.position)
+                val label = Label("_prog8_back", whileLoop.condition.position)
                 whileLoop.body.statements.add(0, label)
                 whileLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf("__back"), whileLoop.condition.position),
+                        IdentifierReference(listOf("_prog8_back"), whileLoop.condition.position),
                         null, whileLoop.condition.position))
                 optimizationsDone++
                 return whileLoop.body
@@ -489,10 +411,15 @@ internal class StatementOptimizer(private val program: Program, private val opti
             throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
 
         if(assignment.target isSameAs assignment.value) {
-            optimizationsDone++
-            return NopStatement.insteadOf(assignment)
+            if(assignment.target.isNotMemory(program.namespace)) {
+                optimizationsDone++
+                return NopStatement.insteadOf(assignment)
+            }
         }
-        val targetDt = assignment.target.inferType(program, assignment)
+        val targetIDt = assignment.target.inferType(program, assignment)
+        if(!targetIDt.isKnown)
+            throw AssemblyError("can't infer type of assignment target")
+        val targetDt = targetIDt.typeOrElse(DataType.STRUCT)
         val bexpr=assignment.value as? BinaryExpression
         if(bexpr!=null) {
             val cv = bexpr.right.constValue(program)?.number?.toDouble()
@@ -589,8 +516,7 @@ internal class StatementOptimizer(private val program: Program, private val opti
                                 optimizationsDone++
                                 return NopStatement.insteadOf(assignment)
                             }
-                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
+                            if ((targetDt == DataType.UWORD && cv > 15.0) || (targetDt == DataType.UBYTE && cv > 7.0)) {
                                 assignment.value = NumericLiteralValue.optimalInteger(0, assignment.value.position)
                                 assignment.value.linkParents(assignment)
                                 optimizationsDone++

compiler/src/prog8/vm/RuntimeValue.kt

@@ -1,10 +1,12 @@
 package prog8.vm
 
 import prog8.ast.base.*
+import prog8.ast.expressions.ArrayLiteralValue
 import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.ast.expressions.StringLiteralValue
 import prog8.compiler.HeapValues
 import prog8.compiler.target.c64.Petscii
+import java.util.*
 import kotlin.math.abs
 import kotlin.math.pow
 
@@ -27,13 +29,8 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             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 fromLv(string: StringLiteralValue, heap: HeapValues): RuntimeValue = fromHeapId(string.heapId!!, heap)
+        fun fromLv(array: ArrayLiteralValue, heap: HeapValues): RuntimeValue = fromHeapId(array.heapId!!, heap)
 
         fun fromHeapId(heapId: Int, heap: HeapValues): RuntimeValue {
             val value = heap.get(heapId)
@@ -107,8 +104,6 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
                 asBoolean = floatval != 0.0
             }
             else -> {
-                if(heapId==null)
-                    throw IllegalArgumentException("for non-numeric types, a heapId should be given")
                 byteval = null
                 wordval = null
                 floatval = null
@@ -156,12 +151,7 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
         }
     }
 
-    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 hashCode(): Int = Objects.hash(byteval, wordval, floatval, type)
 
     override fun equals(other: Any?): Boolean {
         if(other==null || other !is RuntimeValue)
@@ -628,7 +618,7 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
 }
 
 
-class RuntimeValueRange(type: DataType, val range: IntProgression): RuntimeValue(type, 0) {
+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

@@ -7,6 +7,7 @@ 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
@@ -165,10 +166,10 @@ class AstVm(val program: Program) {
     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
+            val timeHi = if(address==0xa0) value else mem.getUByte_DMA(0xa0)
+            val timeMid = if(address==0xa1) value else mem.getUByte_DMA(0xa1)
+            val timeLo = if(address==0xa2) value else mem.getUByte_DMA(0xa2)
+            val jiffies = (timeHi.toInt() shl 16) + (timeMid.toInt() shl 8) + timeLo
             rtcOffset = bootTime - (jiffies*1000/60)
         }
         if(address in 1024..2023) {
@@ -411,9 +412,11 @@ class AstVm(val program: Program) {
                     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())
+                        val elementType = stmt.target.arrayindexed!!.inferType(program)
+                        if(!elementType.isKnown)
+                            throw VmExecutionException("unknown/void elt type")
+                        var value = RuntimeValue(elementType.typeOrElse(DataType.BYTE), arrayvalue.array!![index].toInt())
                         value = when {
                             stmt.operator == "++" -> value.inc()
                             stmt.operator == "--" -> value.dec()
@@ -471,8 +474,9 @@ class AstVm(val program: Program) {
                     loopvarDt = DataType.UBYTE
                     loopvar = IdentifierReference(listOf(stmt.loopRegister.name), stmt.position)
                 } else {
-                    loopvarDt = stmt.loopVar!!.inferType(program)!!
-                    loopvar = stmt.loopVar
+                    val dt = stmt.loopVar!!.inferType(program)
+                    loopvarDt = dt.typeOrElse(DataType.UBYTE)
+                    loopvar = stmt.loopVar!!
                 }
                 val iterator = iterable.iterator()
                 for (loopvalue in iterator) {
@@ -518,7 +522,7 @@ class AstVm(val program: Program) {
                         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 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)
@@ -545,10 +549,12 @@ class AstVm(val program: Program) {
     }
 
     fun performAssignment(target: AssignTarget, value: RuntimeValue, contextStmt: Statement, evalCtx: EvalContext) {
+        val targetIdent = target.identifier
+        val targetArrayIndexed = target.arrayindexed
         when {
-            target.identifier != null -> {
-                val decl = contextStmt.definingScope().lookup(target.identifier.nameInSource, contextStmt) as? VarDecl
-                        ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
+            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) {
@@ -565,14 +571,14 @@ class AstVm(val program: Program) {
                     runtimeVariables.set(decl.definingScope(), decl.name, value)
             }
             target.memoryAddress != null -> {
-                val address = evaluate(target.memoryAddress!!.addressExpression, evalCtx).wordval!!
+                val address = evaluate(target.memoryAddress.addressExpression, evalCtx).wordval!!
                 evalCtx.mem.setUByte(address, value.byteval!!)
             }
-            target.arrayindexed != null -> {
-                val vardecl = target.arrayindexed.identifier.targetVarDecl(program.namespace)!!
+            targetArrayIndexed != null -> {
+                val vardecl = targetArrayIndexed.identifier.targetVarDecl(program.namespace)!!
                 if(vardecl.type==VarDeclType.VAR) {
-                    val array = evaluate(target.arrayindexed.identifier, evalCtx)
-                    val index = evaluate(target.arrayindexed.arrayspec.index, evalCtx)
+                    val array = evaluate(targetArrayIndexed.identifier, evalCtx)
+                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx)
                     when (array.type) {
                         DataType.ARRAY_UB -> {
                             if (value.type != DataType.UBYTE)
@@ -606,7 +612,7 @@ class AstVm(val program: Program) {
                         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(target.arrayindexed.identifier.nameInSource, contextStmt) as? VarDecl
+                        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)
@@ -615,9 +621,11 @@ class AstVm(val program: Program) {
                 }
                 else {
                     val address = (vardecl.value as NumericLiteralValue).number.toInt()
-                    val index = evaluate(target.arrayindexed.arrayspec.index, evalCtx).integerValue()
-                    val elementType = target.arrayindexed.inferType(program)!!
-                    when(elementType) {
+                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx).integerValue()
+                    val elementType = targetArrayIndexed.inferType(program)
+                    if(!elementType.isKnown)
+                        throw VmExecutionException("unknown/void array elt type $targetArrayIndexed")
+                    when(elementType.typeOrElse(DataType.UBYTE)) {
                         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!!)
@@ -673,23 +681,23 @@ class AstVm(val program: Program) {
                 dialog.canvas.printText(args[0].wordval!!.toString(), true)
             }
             "c64scr.print_ubhex" -> {
-                val prefix = if (args[0].asBoolean) "$" else ""
-                val number = args[1].byteval!!
+                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 prefix = if (args[0].asBoolean) "$" else ""
-                val number = args[1].wordval!!
+                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 prefix = if (args[0].asBoolean) "%" else ""
-                val number = args[1].wordval!!
+                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 prefix = if (args[0].asBoolean) "%" else ""
-                val number = args[1].byteval!!
+                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" -> {
@@ -731,7 +739,7 @@ class AstVm(val program: Program) {
                 result = RuntimeValue(DataType.UBYTE, paddedStr.indexOf('\u0000'))
             }
             "c64flt.print_f" -> {
-                dialog.canvas.printText(args[0].floatval.toString(), true)
+                dialog.canvas.printText(args[0].floatval.toString(), false)
             }
             "c64.CHROUT" -> {
                 dialog.canvas.printPetscii(args[0].byteval!!)
@@ -842,10 +850,6 @@ class AstVm(val program: Program) {
                 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) {
@@ -875,27 +879,31 @@ class AstVm(val program: Program) {
                     RuntimeValue(DataType.UBYTE, args[0].str!!.length)
             }
             "memset" -> {
-                val target = args[0].array!!
+                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] = value
+                    target[i] = IntegerOrAddressOf(value, null)
                 }
                 null
             }
             "memsetw" -> {
-                val target = args[0].array!!
+                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] = value and 255
-                    target[i * 2 + 1] = value ushr 8
+                    target[i * 2] = IntegerOrAddressOf(value and 255, null)
+                    target[i * 2 + 1] = IntegerOrAddressOf(value ushr 8, null)
                 }
                 null
             }
             "memcopy" -> {
-                val source = args[0].array!!
-                val dest = args[1].array!!
+                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]
@@ -952,4 +960,3 @@ class AstVm(val program: Program) {
     }
 
 }
-

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

@@ -12,7 +12,6 @@ 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?
@@ -30,12 +29,9 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
         return RuntimeValue.fromLv(constval)
 
     when(expr) {
-        is NumericLiteralValue -> {
-            return RuntimeValue.fromLv(expr)
-        }
-        is ReferenceLiteralValue -> {
-            return RuntimeValue.fromLv(expr, ctx.program.heap)
-        }
+        is NumericLiteralValue -> return RuntimeValue.fromLv(expr)
+        is StringLiteralValue -> return RuntimeValue.fromLv(expr, ctx.program.heap)
+        is ArrayLiteralValue -> return RuntimeValue.fromLv(expr, ctx.program.heap)
         is PrefixExpression -> {
             return when(expr.operator) {
                 "-" -> evaluate(expr.expression, ctx).neg()
@@ -150,24 +146,22 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
         }
         is RangeExpr -> {
             val cRange = expr.toConstantIntegerRange()
-            if(cRange!=null)
-                return RuntimeValueRange(expr.inferType(ctx.program)!!, cRange)
+            if(cRange!=null) {
+                val dt = expr.inferType(ctx.program)
+                if(dt.isKnown)
+                    return RuntimeValueRange(dt.typeOrElse(DataType.UBYTE), cRange)
+                else
+                    throw VmExecutionException("couldn't determine datatype")
+            }
             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)
+            val range = makeRange(fromVal, toVal, stepVal)
+            val dt = expr.inferType(ctx.program)
+            if(dt.isKnown)
+                return RuntimeValueRange(dt.typeOrElse(DataType.UBYTE), range)
+            else
+                throw VmExecutionException("couldn't determine datatype")
         }
         else -> {
             throw VmExecutionException("unimplemented expression node $expr")

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

@@ -5,8 +5,9 @@ import prog8.ast.base.DataType
 import prog8.ast.base.Position
 import prog8.ast.base.Register
 import prog8.ast.base.VarDeclType
+import prog8.ast.expressions.ArrayLiteralValue
 import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.ast.expressions.StringLiteralValue
 import prog8.ast.processing.IAstModifyingVisitor
 import prog8.ast.statements.Statement
 import prog8.ast.statements.StructDecl
@@ -50,8 +51,10 @@ class VariablesCreator(private val runtimeVariables: RuntimeVariables, private v
                         val value = if(numericLv!=null) {
                             RuntimeValue.fromLv(numericLv)
                         } else {
-                            val referenceLv = decl.value as ReferenceLiteralValue
-                            RuntimeValue.fromLv(referenceLv, heap)
+                            if(decl.value is StringLiteralValue)
+                                RuntimeValue.fromLv(decl.value as StringLiteralValue, heap)
+                            else
+                                RuntimeValue.fromLv(decl.value as ArrayLiteralValue, heap)
                         }
                         runtimeVariables.define(decl.definingScope(), decl.name, value)
                     }

compiler/test/LiteralValueTests.kt

@@ -4,8 +4,9 @@ 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.ArrayLiteralValue
 import prog8.ast.expressions.NumericLiteralValue
-import prog8.ast.expressions.ReferenceLiteralValue
+import prog8.ast.expressions.StringLiteralValue
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotEquals
@@ -16,10 +17,6 @@ private fun sameValueAndType(lv1: NumericLiteralValue, lv2: NumericLiteralValue)
     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 {
@@ -86,8 +83,8 @@ class TestParserNumericLiteralValue {
 
     @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)))
+        assertTrue(StringLiteralValue(DataType.STR, "hello", position = dummyPos) == StringLiteralValue(DataType.STR, "hello", position = dummyPos))
+        assertFalse(StringLiteralValue(DataType.STR, "hello", position = dummyPos) == StringLiteralValue(DataType.STR, "bye", position = dummyPos))
 
         val lvOne = NumericLiteralValue(DataType.UBYTE, 1, dummyPos)
         val lvTwo = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
@@ -96,9 +93,9 @@ class TestParserNumericLiteralValue {
         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)
+        val lv1 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOne, lvTwo, lvThree), position = dummyPos)
+        val lv2 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvThreeR), position = dummyPos)
+        val lv3 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvFour), position = dummyPos)
         assertEquals(lv1, lv2)
         assertNotEquals(lv1, lv3)
     }

compiler/test/RuntimeValueTests.kt

@@ -116,18 +116,6 @@ class TestRuntimeValue {
         assertFalse(sameValueAndType(RuntimeValue(DataType.FLOAT, 9.99), RuntimeValue(DataType.FLOAT, 9.0)))
     }
 
-    @Test
-    fun testRequireHeap()
-    {
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.STR, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.STR_S, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.ARRAY_F, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.ARRAY_W, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.ARRAY_UW, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.ARRAY_B, num = 999) }
-        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.ARRAY_UB, num = 999) }
-    }
-
     @Test
     fun testEqualityHeapTypes()
     {

compiler/test/UnitTests.kt

@@ -8,7 +8,7 @@ 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 prog8.ast.expressions.StringLiteralValue
 import prog8.compiler.*
 import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
@@ -145,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
@@ -165,14 +169,24 @@ class TestZeropage {
         }
     }
 
+    @Test
+    fun testZpDontuse() {
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false))
+        println(zp.free)
+        assertEquals(0, zp.available())
+        assertFailsWith<CompilerException> {
+            zp.allocate("", DataType.BYTE, null)
+        }
+    }
+
     @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())
     }
@@ -202,11 +216,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)
         }
 
@@ -256,16 +269,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())
     }
@@ -358,8 +371,8 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = ReferenceLiteralValue(DataType.STR, str = "abc", position = Position("", 0, 0, 0))
-        val abd = ReferenceLiteralValue(DataType.STR, str = "abd", position = Position("", 0, 0, 0))
+        val abc = StringLiteralValue(DataType.STR, "abc", position = Position("", 0, 0, 0))
+        val abd = StringLiteralValue(DataType.STR, "abd", position = Position("", 0, 0, 0))
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)

docs/source/building.rst

@@ -87,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 (less than a 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
 ------------------------
@@ -101,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)

docs/source/index.rst

@@ -45,7 +45,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
@@ -101,7 +101,7 @@ The following programs shows a use of the high level ``struct`` type::
     %import c64utils
     %zeropage basicsafe
 
-    ~ main {
+    main {
 
         struct Color {
             ubyte red
@@ -140,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.
@@ -150,13 +151,14 @@ Design principles and features
   the compiled program in an emulator and provide debugging information to the emulator.
 - The compiler outputs a regular 6502 assembly source code file, but doesn't assemble this itself.
   The (separate) '64tass' cross-assembler tool is used for that.
-- Goto is usually considered harmful, but not here: arbitrary control flow jumps and branches are possible,
+- Arbitrary control flow jumps and branches are possible,
   and will usually translate directly into the appropriate single 6502 jump/branch instruction.
 - There are no complicated built-in error handling or overflow checks, you'll have to take care
   of this yourself if required. This keeps the language and code simple and efficient.
 - The compiler tries to optimize the program and generated code, but hand-tuning of the
   performance or space-critical parts will likely still be required. This is supported by
   the ability to easily write embedded assembly code directly in the program source code.
+- There are many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
 
 
 .. _requirements:

docs/source/programming.rst

@@ -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
@@ -387,8 +395,7 @@ Loops
 -----
 
 The *for*-loop is used to let a variable (or register) iterate over a range of values. Iteration is done in steps of 1, but you can change this.
-The loop variable can be declared as byte or word earlier so you can reuse it for multiple occasions,
-or you can declare one directly in the for statement which will only be visible in the for loop body.
+The loop variable must be declared as byte or word earlier so you can reuse it for multiple occasions.
 Iterating with a floating point variable is not supported. If you want to loop over a floating-point array, use a loop with an integer index variable instead.
 
 The *while*-loop is used to repeat a piece of code while a certain condition is still true.
@@ -400,7 +407,6 @@ 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.
 
 
 Conditional Execution
@@ -653,55 +659,58 @@ cos16u(x)
     Fast 16-bit uword cosine of angle 0..255, result is in range 0..65535
 
 cos16(x)
-    Fast 16-bit word cosine of angle 0..255, result is in range -32767..32767
+   Fast 16-bit word cosine of angle 0..255, result is in range -32767..32767
 
 abs(x)
-	Absolute value.
+    Absolute value.
 
 tan(x)
-	Tangent.
+    Tangent.
 
 atan(x)
-	Arctangent.
+    Arctangent.
 
 ln(x)
-	Natural logarithm (base e).
+    Natural logarithm (base e).
 
 log2(x)
     Base 2 logarithm.
 
 sqrt16(w)
-	16 bit unsigned integer Square root. Result is unsigned byte.
+    16 bit unsigned integer Square root. Result is unsigned byte.
 
 sqrt(x)
-	Floating point Square root.
+    Floating point Square root.
 
 round(x)
-	Rounds the floating point to the closest integer.
+    Rounds the floating point to the closest integer.
 
 floor (x)
-	Rounds the floating point down to an integer towards minus infinity.
+    Rounds the floating point down to an integer towards minus infinity.
 
 ceil(x)
-	Rounds the floating point up to an integer towards positive infinity.
+    Rounds the floating point up to an integer towards positive infinity.
 
 rad(x)
-	Degrees to radians.
+    Degrees to radians.
 
 deg(x)
-	Radians to degrees.
+    Radians to degrees.
 
 max(x)
-	Maximum of the values in the array value x
+    Maximum of the values in the array value x
 
 min(x)
-	Minimum of the values in the array value x
-
-avg(x)
-	Average of the values in the array value x
+    Minimum of the values in the array value x
 
 sum(x)
-	Sum of the values in the array value x
+    Sum of the values in the array value x
+
+sort(array)
+    Sort the array in ascending order (in-place)
+
+reverse(array)
+    Reverse the values in the array (in-place). Can be used after sort() to sort an array in descending order.
 
 len(x)
     Number of values in the array value x, or the number of characters in a string (excluding the size or 0-byte).
@@ -720,6 +729,9 @@ lsb(x)
 msb(x)
     Get the most significant byte of the word x.
 
+sgn(x)
+    Get the sign of the value. Result is -1, 0 or 1 (negative, zero, positive).
+
 mkword(lsb, msb)
     Efficiently create a word value from two bytes (the lsb and the msb). Avoids multiplication and shifting.
 

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...
 	}
 
@@ -387,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: ``&``  ``|``  ``^``  ``~``  ``<<``  ``>>``
@@ -516,42 +517,39 @@ Loops
 for loop
 ^^^^^^^^
 
-The loop variable must be a register or a byte/word variable. It must be defined in the local scope (to reuse
-an existing variable), or you can declare it in the for loop directly to make a new one that is only visible
-in the body of the for loop.
+The loop variable must be a register or a byte/word variable,
+and must be defined first in the local scope of the for loop.
 The expression that you loop over can be anything that supports iteration (such as ranges like ``0 to 100``,
 array variables and strings) *except* floating-point arrays (because a floating-point loop variable is not supported).
 
 You can use a single statement, or a statement block like in the example below::
 
-	for [byte | word]  <loopvar>  in  <expression>  [ step <amount> ]   {
+	for <loopvar>  in  <expression>  [ step <amount> ]   {
 		; do something...
 		break		; break out of the loop
 		continue	; immediately enter next iteration
 	}
 
-For example, this is a for loop using the existing byte variable ``i`` to loop over a certain range of numbers::
+For example, this is a for loop using a byte variable ``i``, defined before, to loop over a certain range of numbers::
+
+    ubyte i
+
+    ...
 
     for i in 20 to 155 {
         ; do something
     }
 
-And this is a loop over the values of the array ``fibonacci_numbers`` where the loop variable is declared in the loop itself::
+And this is a loop over the values of the array ``fibonacci_numbers``::
 
-    word[] fibonacci_numbers = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
+    uword[] fibonacci_numbers = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
 
-    for word fibnr in fibonacci_numbers {
-        ; do something
+    uword number
+    for number in fibonacci_numbers {
+        ; do something with number
     }
 
 
-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
-    }
-
 
 while loop
 ^^^^^^^^^^

docs/source/targetsystem.rst

@@ -168,7 +168,7 @@ These routines are::
 If you activate an IRQ handler with one of these, it expects the handler to be defined
 as a subroutine ``irq`` in the module ``irq`` so like this::
 
-    ~ irq {
+    irq {
         sub irq() {
             ; ... irq handling here ...
         }

docs/source/todo.rst

@@ -5,20 +5,17 @@ TODO
 Memory Block Operations integrated in language?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-list,string memory block operations?
+array/string memory block operations?
 
-- list operations (whole list, individual element)
-  operations: set, get, copy (from another list with the same length), shift-N(left,right), rotate-N(left,right)
-  clear (set whole list to the given value, default 0)
+- array operations
+  copy (from another array with the same length), shift-N(left,right), rotate-N(left,right)
+  clear (set whole array to the given value, default 0)
 
-- list operations ofcourse work identical on vars and on memory mapped vars of these types.
+- array operations ofcourse work identical on vars and on memory mapped vars of these types.
 
-- strings: identical operations as on lists.
-
-these should call optimized pieces of assembly code, so they run as fast as possible
-
-For now, we have the ``memcopy``, ``memset`` and ``strlen`` builtin functions.
+- strings: identical operations as on array.
 
+For now, we have the ``memcopy`` and ``memset`` builtin functions.
 
 
 More optimizations
@@ -27,14 +24,9 @@ More optimizations
 Add more compiler optimizations to the existing ones.
 
 - on the language AST level
-- on the StackVM intermediate code level
 - on the final assembly source level
 - can the parameter passing to subroutines be optimized to avoid copying?
-
-- subroutines with 1 or 2 byte args (or 1 word arg) should be converted to asm calling convention with the args in A/Y register
-  this requires rethinking the way parameters are represented, simply injecting vardecls to
-  declare local variables for them is not always correct anymore
-
+- working subroutine inlining (taking care of vars and identifier refs to them)
 
 Also some library routines and code patterns could perhaps be optimized further
 
@@ -48,11 +40,13 @@ It could then even be moved into the zeropage to greatly reduce code size and sl
 
 Or just move the LSB portion into a slab of the zeropage.
 
-Allocate a fixed word in ZP that is the TOS so we can operate on TOS directly
+Allocate a fixed word in ZP that is the TOS so we can always operate on TOS directly
 without having to to index into the stack?
 
 
 Misc
 ^^^^
 
-- are there any other missing instructions in the code generator?
+Several ideas were discussed on my reddit post
+https://www.reddit.com/r/programming/comments/alhj59/creating_a_programming_language_and_cross/
+

examples/arithmetic/aggregates.p8

@@ -0,0 +1,110 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage dontuse
+
+main {
+
+    sub start() {
+        ubyte[]  ubarr = [100, 0, 99, 199, 22]
+        byte[]  barr = [-100, 0, 99, -122, 22]
+        uword[] uwarr = [1000, 0, 222, 4444, 999]
+        word[]  warr = [-1000, 0, 999, -4444, 222]
+        float[]  farr = [-1000.1, 0, 999.9, -4444.4, 222.2]
+        str name = "irmen"
+        ubyte ub
+        byte bb
+        word ww
+        uword uw
+        float ff
+
+        ; LEN/STRLEN
+        ubyte length = len(name)
+        if length!=5 c64scr.print("error len1\n")
+        length = len(uwarr)
+        if length!=5 c64scr.print("error len2\n")
+        length=strlen(name)
+        if length!=5 c64scr.print("error strlen1\n")
+        name[3] = 0
+        length=strlen(name)
+        if length!=3 c64scr.print("error strlen2\n")
+
+        ; MAX
+        ub = max(ubarr)
+        if ub!=199 c64scr.print("error max1\n")
+        bb = max(barr)
+        if bb!=99 c64scr.print("error max2\n")
+        uw = max(uwarr)
+        if uw!=4444 c64scr.print("error max3\n")
+        ww = max(warr)
+        if ww!=999 c64scr.print("error max4\n")
+        ff = max(farr)
+        if ff!=999.9 c64scr.print("error max5\n")
+
+        ; MIN
+        ub = min(ubarr)
+        if ub!=0 c64scr.print("error min1\n")
+        bb = min(barr)
+        if bb!=-122 c64scr.print("error min2\n")
+        uw = min(uwarr)
+        if uw!=0 c64scr.print("error min3\n")
+        ww = min(warr)
+        if ww!=-4444 c64scr.print("error min4\n")
+        ff = min(farr)
+        if ff!=-4444.4 c64scr.print("error min5\n")
+
+        ; SUM
+        uw = sum(ubarr)
+        if uw!=420 c64scr.print("error sum1\n")
+        ww = sum(barr)
+        if ww!=-101 c64scr.print("error sum2\n")
+        uw = sum(uwarr)
+        if uw!=6665 c64scr.print("error sum3\n")
+        ww = sum(warr)
+        if ww!=-4223 c64scr.print("error sum4\n")
+        ff = sum(farr)
+        if ff!=-4222.4 c64scr.print("error sum5\n")
+
+        ; ANY
+        ub = any(ubarr)
+        if ub==0 c64scr.print("error any1\n")
+        ub = any(barr)
+        if ub==0 c64scr.print("error any2\n")
+        ub = any(uwarr)
+        if ub==0 c64scr.print("error any3\n")
+        ub = any(warr)
+        if ub==0 c64scr.print("error any4\n")
+        ub = any(farr)
+        if ub==0 c64scr.print("error any5\n")
+
+        ; ALL
+        ub = all(ubarr)
+        if ub==1 c64scr.print("error all1\n")
+        ub = all(barr)
+        if ub==1 c64scr.print("error all2\n")
+        ub = all(uwarr)
+        if ub==1 c64scr.print("error all3\n")
+        ub = all(warr)
+        if ub==1 c64scr.print("error all4\n")
+        ub = all(farr)
+        if ub==1 c64scr.print("error all5\n")
+        ubarr[1]=$40
+        barr[1]=$40
+        uwarr[1]=$4000
+        warr[1]=$4000
+        farr[1]=1.1
+        ub = all(ubarr)
+        if ub==0 c64scr.print("error all6\n")
+        ub = all(barr)
+        if ub==0 c64scr.print("error all7\n")
+        ub = all(uwarr)
+        if ub==0 c64scr.print("error all8\n")
+        ub = all(warr)
+        if ub==0 c64scr.print("error all9\n")
+        ub = all(farr)
+        if ub==0 c64scr.print("error all10\n")
+
+
+        c64scr.print("\nyou should see no errors above.")
+    }
+}

examples/arithmetic/bitshift.p8

@@ -0,0 +1,77 @@
+%import c64utils
+%zeropage basicsafe
+
+; TODO implement asm generation for all operation in here
+
+main {
+
+    byte bb
+    ubyte ub
+    word ww
+    uword uw
+    &ubyte  membyte=9999
+    &uword  memword=9999
+    ubyte[10] barray
+
+    sub start() {
+        lsr(A)
+        lsl(A)
+        ror(A)
+        rol(A)
+        ror2(A)
+        rol2(A)
+        lsr(membyte)
+        lsl(membyte)
+        ror(membyte)
+        rol(membyte)
+        ror2(membyte)
+        rol2(membyte)
+        lsr(memword)
+        lsl(memword)
+        ror(memword)
+        rol(memword)
+        ror2(memword)
+        rol2(memword)
+        lsl(@(9999))
+        lsr(@(9999))
+        ror(@(9999))
+        rol(@(9999))
+        ror2(@(9999))
+        rol2(@(9999))
+        lsr(barray[1])
+        lsl(barray[1])
+        ror(barray[1])
+        rol(barray[1])
+        ror2(barray[1])
+        rol2(barray[1])
+
+
+        bb /= 2
+        bb >>= 1
+        bb *= 4
+        bb <<= 2
+
+        ub /= 2
+        ub >>= 1
+        ub *= 4
+        ub <<= 2
+        rol(ub)
+        ror(ub)
+        rol2(ub)
+        ror2(ub)
+
+        ww /= 2
+        ww >>= 1
+        ww *= 4
+        ww <<= 2
+
+        uw /= 2
+        uw >>= 1
+        uw *= 4
+        uw <<= 2
+        rol(uw)
+        ror(uw)
+        rol2(uw)
+        ror2(uw)
+    }
+}

examples/arithmetic/div.p8

@@ -0,0 +1,105 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        div_ubyte(0, 1, 0)
+        div_ubyte(100, 6, 16)
+        div_ubyte(255, 2, 127)
+
+        div_byte(0, 1, 0)
+        div_byte(100, -6, -16)
+        div_byte(127, -2, -63)
+
+        div_uword(0,1,0)
+        div_uword(40000,500,80)
+        div_uword(43211,2,21605)
+
+        div_word(0,1,0)
+        div_word(-20000,500,-40)
+        div_word(-2222,2,-1111)
+
+        div_float(0,1,0)
+        div_float(999.9,111.0,9.008108108108107)
+
+    }
+
+    sub div_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" / ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_byte(byte a1, byte a2, byte c) {
+        byte r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" / ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" / ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_word(word a1, word a2, word c) {
+        word r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" / ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_float(float  a1, float a2, float  c) {
+        float r = a1/a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" / ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/arithmetic/minus.p8

@@ -0,0 +1,113 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        minus_ubyte(0, 0, 0)
+        minus_ubyte(200, 0, 200)
+        minus_ubyte(200, 100, 100)
+        minus_ubyte(100, 200, 156)
+
+        minus_byte(0, 0, 0)
+        minus_byte(100, 100, 0)
+        minus_byte(50, -50, 100)
+        minus_byte(0, -30, 30)
+        minus_byte(-30, 0, -30)
+
+        minus_uword(0,0,0)
+        minus_uword(50000,0, 50000)
+        minus_uword(50000,20000,30000)
+        minus_uword(20000,50000,35536)
+
+        minus_word(0,0,0)
+        minus_word(1000,1000,0)
+        minus_word(-1000,1000,-2000)
+        minus_word(1000,500,500)
+        minus_word(0,-3333,3333)
+        minus_word(-3333,0,-3333)
+
+        minus_float(0,0,0)
+        minus_float(2.5,1.5,1.0)
+        minus_float(-1.5,3.5,-5.0)
+
+    }
+
+    sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" - ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_byte(byte a1, byte a2, byte c) {
+        byte r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" - ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" - ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_word(word a1, word a2, word c) {
+        word r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" - ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_float(float  a1, float a2, float  c) {
+        float r = a1-a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" - ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/arithmetic/mult.p8

@@ -0,0 +1,107 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        mul_ubyte(0, 0, 0)
+        mul_ubyte(20, 1, 20)
+        mul_ubyte(20, 10, 200)
+
+        mul_byte(0, 0, 0)
+        mul_byte(10, 10, 100)
+        mul_byte(5, -5, -25)
+        mul_byte(0, -30, 0)
+
+        mul_uword(0,0,0)
+        mul_uword(50000,1, 50000)
+        mul_uword(500,100,50000)
+
+        mul_word(0,0,0)
+        mul_word(-10,1000,-10000)
+        mul_word(1,-3333,-3333)
+
+        mul_float(0,0,0)
+        mul_float(2.5,10,25)
+        mul_float(-1.5,10,-15)
+
+    }
+
+    sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" * ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_byte(byte a1, byte a2, byte c) {
+        byte r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" * ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" * ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_word(word a1, word a2, word c) {
+        word r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" * ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_float(float  a1, float a2, float  c) {
+        float r = a1*a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" * ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/arithmetic/plus.p8

@@ -0,0 +1,111 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        plus_ubyte(0, 0, 0)
+        plus_ubyte(0, 200, 200)
+        plus_ubyte(100, 200, 44)
+
+        plus_byte(0, 0, 0)
+        plus_byte(-100, 100, 0)
+        plus_byte(-50, 100, 50)
+        plus_byte(0, -30, -30)
+        plus_byte(-30, 0, -30)
+
+        plus_uword(0,0,0)
+        plus_uword(0,50000,50000)
+        plus_uword(50000,20000,4464)
+
+        plus_word(0,0,0)
+        plus_word(-1000,1000,0)
+        plus_word(-500,1000,500)
+        plus_word(0,-3333,-3333)
+        plus_word(-3333,0,-3333)
+
+        plus_float(0,0,0)
+        plus_float(1.5,2.5,4.0)
+        plus_float(-1.5,3.5,2.0)
+        plus_float(-1.1,3.3,2.2)
+
+    }
+
+    sub plus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" + ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_byte(byte a1, byte a2, byte c) {
+        byte r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" + ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" + ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_word(word a1, word a2, word c) {
+        word r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" + ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_float(float  a1, float a2, float  c) {
+        float r = a1+a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" + ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}

examples/arithmetic/postincrdecr.p8

@@ -0,0 +1,142 @@
+%import c64utils
+%import c64flt
+%option enable_floats
+%zeropage basicsafe
+
+main {
+
+
+    sub start()  {
+
+        c64scr.plot(0,24)
+
+        ubyte ub=200
+        byte bb=-100
+        uword uw = 2000
+        word ww = -1000
+        float fl = 999.99
+        ubyte[3] ubarr = 200
+        byte[3] barr = -100
+        uword[3] uwarr = 2000
+        word[3] warr = -1000
+        float[3] flarr = 999.99
+
+        c64scr.print("++\n")
+        ub++
+        bb++
+        uw++
+        ww++
+        fl++
+        ubarr[1]++
+        barr[1]++
+        uwarr[1]++
+        warr[1]++
+        flarr[1] ++
+
+        check_ub(ub, 201)
+        Y=100
+        Y++
+        check_ub(Y, 101)
+        check_fl(fl, 1000.99)
+        check_b(bb, -99)
+        check_uw(uw, 2001)
+        check_w(ww, -999)
+        check_ub(ubarr[0], 200)
+        check_fl(flarr[0], 999.99)
+        check_b(barr[0], -100)
+        check_uw(uwarr[0], 2000)
+        check_w(warr[0], -1000)
+        check_ub(ubarr[1], 201)
+        check_fl(flarr[1], 1000.99)
+        check_b(barr[1], -99)
+        check_uw(uwarr[1], 2001)
+        check_w(warr[1], -999)
+
+        c64scr.print("--\n")
+        ub--
+        bb--
+        uw--
+        ww--
+        fl--
+        ubarr[1]--
+        barr[1]--
+        uwarr[1]--
+        warr[1]--
+        flarr[1] --
+        check_ub(ub, 200)
+        Y=100
+        Y--
+        check_ub(Y, 99)
+        check_fl(fl, 999.99)
+        check_b(bb, -100)
+        check_uw(uw, 2000)
+        check_w(ww, -1000)
+        check_ub(ubarr[1], 200)
+        check_fl(flarr[1], 999.99)
+        check_b(barr[1], -100)
+        check_uw(uwarr[1], 2000)
+        check_w(warr[1], -1000)
+
+        @($0400+400-1) = X
+    }
+
+    sub check_ub(ubyte value, ubyte expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" ubyte ")
+        c64scr.print_ub(value)
+        c64.CHROUT(',')
+        c64scr.print_ub(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_b(byte value, byte expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" byte ")
+        c64scr.print_b(value)
+        c64.CHROUT(',')
+        c64scr.print_b(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_uw(uword value, uword expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" uword ")
+        c64scr.print_uw(value)
+        c64.CHROUT(',')
+        c64scr.print_uw(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_w(word value, word expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" word ")
+        c64scr.print_w(value)
+        c64.CHROUT(',')
+        c64scr.print_w(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_fl(float value, float expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" float ")
+        c64flt.print_f(value)
+        c64.CHROUT(',')
+        c64flt.print_f(expected)
+        c64.CHROUT('\n')
+    }
+}

examples/arithmetic/remainder.p8

@@ -0,0 +1,49 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        remainder_ubyte(0, 1, 0)
+        remainder_ubyte(100, 6, 4)
+        remainder_ubyte(255, 2, 1)
+        remainder_ubyte(255, 20, 15)
+
+        remainder_uword(0,1,0)
+        remainder_uword(40000,511,142)
+        remainder_uword(40000,500,0)
+        remainder_uword(43211,12,11)
+    }
+
+    sub remainder_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1%a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" % ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub remainder_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1%a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" % ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+}

examples/bdmusic-irq.p8

@@ -0,0 +1,74 @@
+%zeropage basicsafe
+%import c64lib
+
+main {
+
+    sub start() {
+        c64scr.print("playing the music from boulderdash,\nmade in 1984 by peter liepa.\n\n")
+        c64utils.set_rasterirq(60)     ; enable raster irq
+    }
+}
+
+irq {
+    const ubyte waveform = %0001       ; triangle
+    ubyte note_index = 0
+    ubyte delay = 0
+
+    sub irq() {
+        c64.EXTCOL++
+        delay++
+        if delay >= 8 {
+            delay = 0
+            c64.AD1 = %00011010
+            c64.SR1 = %00000000
+            c64.AD2 = %00011010
+            c64.SR2 = %00000000
+            c64.MVOL = 15
+
+            uword note = notes[note_index]
+            note_index++
+            ubyte note1 = lsb(note)
+            ubyte note2 = msb(note)
+            c64.FREQ1 = music_freq_table[note1]    ; set lo+hi freq of voice 1
+            c64.FREQ2 = music_freq_table[note2]    ; set lo+hi freq of voice 2
+
+            ; retrigger voice 1 and 2 ADSR
+            c64.CR1 = waveform <<4 | 0
+            c64.CR2 = waveform <<4 | 0
+            c64.CR1 = waveform <<4 | 1
+            c64.CR2 = waveform <<4 | 1
+        }
+
+        c64.EXTCOL--
+    }
+
+    ; details about the boulderdash music can be found here:
+    ; https://www.elmerproductions.com/sp/peterb/sounds.html#Theme%20tune
+
+    uword[] notes = [
+        $1622, $1d26, $2229, $252e, $1424, $1f27, $2029, $2730,
+        $122a, $122c, $1e2e, $1231, $202c, $3337, $212d, $3135,
+        $1622, $162e, $161d, $1624, $1420, $1430, $1424, $1420,
+        $1622, $162e, $161d, $1624, $1e2a, $1e3a, $1e2e, $1e2a,
+        $142c, $142c, $141b, $1422, $1c28, $1c38, $1c2c, $1c28,
+        $111d, $292d, $111f, $292e, $0f27, $0f27, $1633, $1627,
+        $162e, $162e, $162e, $162e, $222e, $222e, $162e, $162e,
+        $142e, $142e, $142e, $142e, $202e, $202e, $142e, $142e,
+        $162e, $322e, $162e, $332e, $222e, $322e, $162e, $332e,
+        $142e, $322e, $142e, $332e, $202c, $302c, $142c, $312c,
+        $162e, $163a, $162e, $3538, $222e, $2237, $162e, $3135,
+        $142c, $1438, $142c, $1438, $202c, $2033, $142c, $1438,
+        $162e, $322e, $162e, $332e, $222e, $322e, $162e, $332e,
+        $142e, $322e, $142e, $332e, $202c, $302c, $142c, $312c,
+        $2e32, $292e, $2629, $2226, $2c30, $272c, $2427, $1420,
+        $3532, $322e, $2e29, $2926, $2730, $242c, $2027, $1420
+    ]
+
+    uword[] music_freq_table = [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        732, 778, 826, 876, 928, 978, 1042, 1100, 1170, 1238, 1312, 1390, 1464, 1556,
+        1652, 1752, 1856, 1956, 2084, 2200, 2340, 2476, 2624, 2780, 2928, 3112, 3304,
+        3504, 3712, 3912, 4168, 4400, 4680, 4952, 5248, 5560, 5856, 6224, 6608, 7008,
+        7424, 7824, 8336, 8800, 9360, 9904, 10496, 11120, 11712
+    ]
+}

examples/bdmusic.p8

@@ -1,6 +1,6 @@
 %import c64lib
 
-~ main {
+main {
 
 sub start() {
 
@@ -17,11 +17,12 @@ sub start() {
     c64.CLEARSCR()
 
     while(true) {
-        for uword note in notes {
-            ubyte n1 = lsb(note)
-            ubyte n2 = msb(note)
-            c64.FREQ1 = music_freq_table[n1]    ; set lo+hi freq of voice 1
-            c64.FREQ2 = music_freq_table[n2]    ; set lo+hi freq of voice 2
+        uword note
+        for note in notes {
+            ubyte note1 = lsb(note)
+            ubyte note2 = msb(note)
+            c64.FREQ1 = music_freq_table[note1]    ; set lo+hi freq of voice 1
+            c64.FREQ2 = music_freq_table[note2]    ; set lo+hi freq of voice 2
 
             ; retrigger voice 1 and 2 ADSR
             c64.CR1 = waveform <<4 | 0
@@ -29,13 +30,14 @@ sub start() {
             c64.CR1 = waveform <<4 | 1
             c64.CR2 = waveform <<4 | 1
 
-            print_notes(n1, n2)
+            print_notes(note1, note2)
             delay()
         }
     }
 
     sub delay() {
-        for ubyte d in 0 to 12 {
+        ubyte d
+        for d in 0 to 12 {
             while(c64.RASTER!=0) {
                 ; tempo delay synced to screen refresh
             }

examples/comparison_ifs_byte.p8

@@ -2,7 +2,7 @@
 %zeropage basicsafe
 
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparison_ifs_float.p8

@@ -2,7 +2,7 @@
 %import c64flt
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparison_ifs_ubyte.p8

@@ -2,7 +2,7 @@
 %zeropage basicsafe
 
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparison_ifs_uword.p8

@@ -2,7 +2,7 @@
 %zeropage basicsafe
 
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparison_ifs_word.p8

@@ -2,7 +2,7 @@
 %zeropage basicsafe
 
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparisons_byte.p8

@@ -1,7 +1,7 @@
 %import c64utils
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparisons_float.p8

@@ -2,7 +2,7 @@
 %import c64flt
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparisons_ubyte.p8

@@ -1,7 +1,7 @@
 %import c64utils
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparisons_uword.p8

@@ -1,7 +1,7 @@
 %import c64utils
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/comparisons_word.p8

@@ -1,7 +1,7 @@
 %import c64utils
 %zeropage basicsafe
 
-~ main {
+main {
 
     sub start()  {
 

examples/cube3d-float.p8

@@ -2,7 +2,7 @@
 %import c64utils
 %import c64flt
 
-~ main {
+main {
 
     const uword width = 40
     const uword height = 25
@@ -55,7 +55,8 @@
         float Azy = cosb*sinc
         float Azz = cosb*cosc
 
-        for ubyte i in 0 to len(xcoor)-1 {
+        ubyte i
+        for i in 0 to len(xcoor)-1 {
             rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
             rotatedy[i] = Ayx*xcoor[i] + Ayy*ycoor[i] + Ayz*zcoor[i]
             rotatedz[i] = Azx*xcoor[i] + Azy*ycoor[i] + Azz*zcoor[i]
@@ -66,23 +67,28 @@
 
         ; plot the points of the 3d cube
         ; first the points on the back, then the points on the front (painter algorithm)
+        ubyte i
+        float rz
+        float persp
+        ubyte sx
+        ubyte sy
 
-        for ubyte i in 0 to len(xcoor)-1 {
-            float rz = rotatedz[i]
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
             if rz >= 0.1 {
-                float persp = (5.0+rz)/height
-                ubyte sx = rotatedx[i] / persp + width/2.0 as ubyte
-                ubyte sy = rotatedy[i] / persp + height/2.0 as ubyte
+                persp = (5.0+rz)/height
+                sx = rotatedx[i] / persp + width/2.0 as ubyte
+                sy = rotatedy[i] / persp + height/2.0 as ubyte
                 c64scr.setcc(sx, sy, 46, i+2)
             }
         }
 
-        for ubyte i in 0 to len(xcoor)-1 {
-            float rz = rotatedz[i]
+        for i in 0 to len(xcoor)-1 {
+            rz = rotatedz[i]
             if rz < 0.1 {
-                float persp = (5.0+rz)/height
-                ubyte sx = rotatedx[i] / persp + width/2.0 as ubyte
-                ubyte sy = rotatedy[i] / persp + height/2.0 as ubyte
+                persp = (5.0+rz)/height
+                sx = rotatedx[i] / persp + width/2.0 as ubyte
+                sy = rotatedy[i] / persp + height/2.0 as ubyte
                 c64scr.setcc(sx, sy, 81, i+2)
             }
         }