Merge branch 'codegen-on-new-ast'

codeCore/src/prog8/code/SymbolTable.kt

@@ -1,5 +1,7 @@
 package prog8.code
 
+import prog8.code.ast.PtNode
+import prog8.code.ast.PtProgram
 import prog8.code.core.*
 
 
@@ -7,7 +9,7 @@ import prog8.code.core.*
  * Tree structure containing all symbol definitions in the program
  * (blocks, subroutines, variables (all types), memoryslabs, and labels).
  */
-class SymbolTable : StNode("", StNodeType.GLOBAL, Position.DUMMY) {
+class SymbolTable(astProgram: PtProgram) : StNode(astProgram.name, StNodeType.GLOBAL, astProgram) {
     /**
      * The table as a flat mapping of scoped names to the StNode.
      * This gives the fastest lookup possible (no need to traverse tree nodes)
@@ -76,7 +78,7 @@ enum class StNodeType {
 
 open class StNode(val name: String,
                   val type: StNodeType,
-                  val position: Position,
+                  val astNode: PtNode,
                   val children: MutableMap<String, StNode> = mutableMapOf()
 ) {
 
@@ -150,8 +152,8 @@ class StStaticVariable(name: String,
                        val onetimeInitializationStringValue: StString?,
                        val onetimeInitializationArrayValue: StArray?,
                        val length: Int?,            // for arrays: the number of elements, for strings: number of characters *including* the terminating 0-byte
-                       val zpwish: ZeropageWish,
-                       position: Position) : StNode(name, StNodeType.STATICVAR, position) {
+                       val zpwish: ZeropageWish,    // used in the variable allocator
+                       astNode: PtNode) : StNode(name, StNodeType.STATICVAR, astNode) {
 
     init {
         if(bss) {
@@ -180,8 +182,8 @@ class StStaticVariable(name: String,
 }
 
 
-class StConstant(name: String, val dt: DataType, val value: Double, position: Position) :
-    StNode(name, StNodeType.CONSTANT, position) {
+class StConstant(name: String, val dt: DataType, val value: Double, astNode: PtNode) :
+    StNode(name, StNodeType.CONSTANT, astNode) {
 }
 
 
@@ -189,31 +191,31 @@ class StMemVar(name: String,
                val dt: DataType,
                val address: UInt,
                val length: Int?,             // for arrays: the number of elements, for strings: number of characters *including* the terminating 0-byte
-               position: Position) :
-    StNode(name, StNodeType.MEMVAR, position) {
+               astNode: PtNode) :
+    StNode(name, StNodeType.MEMVAR, astNode) {
 }
 
 class StMemorySlab(
     name: String,
     val size: UInt,
     val align: UInt,
-    position: Position
+    astNode: PtNode
 ):
-    StNode(name, StNodeType.MEMORYSLAB, position) {
+    StNode(name, StNodeType.MEMORYSLAB, astNode) {
 }
 
-class StSub(name: String, val parameters: List<StSubroutineParameter>, val returnType: DataType?, position: Position) :
-        StNode(name, StNodeType.SUBROUTINE, position) {
+class StSub(name: String, val parameters: List<StSubroutineParameter>, val returnType: DataType?, astNode: PtNode) :
+        StNode(name, StNodeType.SUBROUTINE, astNode) {
 }
 
 
 class StRomSub(name: String,
                val address: UInt,
                val parameters: List<StRomSubParameter>,
-               val returns: List<RegisterOrStatusflag>,
-               position: Position) :
-    StNode(name, StNodeType.ROMSUB, position) {
-}
+               val returns: List<StRomSubParameter>,
+               astNode: PtNode) :
+    StNode(name, StNodeType.ROMSUB, astNode)
+
 
 
 class StSubroutineParameter(val name: String, val type: DataType)

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -0,0 +1,211 @@
+package prog8.code
+
+import prog8.code.ast.*
+import prog8.code.core.*
+import prog8.code.target.VMTarget
+import java.util.*
+
+class SymbolTableMaker(private val program: PtProgram, private val options: CompilationOptions) {
+    fun make(): SymbolTable {
+        val st = SymbolTable(program)
+
+        BuiltinFunctions.forEach {
+            st.add(StNode(it.key, StNodeType.BUILTINFUNC, PtIdentifier(it.key, it.value.returnType ?: DataType.UNDEFINED, Position.DUMMY)))
+        }
+
+        val scopestack = Stack<StNode>()
+        scopestack.push(st)
+        program.children.forEach {
+            addToSt(it, scopestack)
+        }
+        require(scopestack.size==1)
+
+        if(options.compTarget.name != VMTarget.NAME) {
+            listOf(
+                PtMemMapped("P8ZP_SCRATCH_B1", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_B1, null, Position.DUMMY),
+                PtMemMapped("P8ZP_SCRATCH_REG", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_REG, null, Position.DUMMY),
+                PtMemMapped("P8ZP_SCRATCH_W1", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W1, null, Position.DUMMY),
+                PtMemMapped("P8ZP_SCRATCH_W2", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W2, null, Position.DUMMY),
+                PtMemMapped("P8ESTACK_LO", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_LO, 256u, Position.DUMMY),
+                PtMemMapped("P8ESTACK_HI", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_HI, 256u, Position.DUMMY)
+            ).forEach {
+                it.parent = program
+                st.add(StMemVar(it.name, it.type, it.address, null, it))
+            }
+        }
+
+        return st
+    }
+
+    private fun addToSt(node: PtNode, scope: Stack<StNode>) {
+        val stNode = when(node) {
+            is PtAsmSub -> {
+                if(node.address==null) {
+                    val params = node.parameters.map { StSubroutineParameter(it.second.name, it.second.type) }
+                    StSub(node.name, params, node.returns.singleOrNull()?.second, node)
+                } else {
+                    val parameters = node.parameters.map { StRomSubParameter(it.first, it.second.type) }
+                    val returns = node.returns.map { StRomSubParameter(it.first, it.second) }
+                    StRomSub(node.name, node.address, parameters, returns, node)
+                }
+            }
+            is PtBlock -> {
+                StNode(node.name, StNodeType.BLOCK, node)
+            }
+            is PtConstant -> {
+                StConstant(node.name, node.type, node.value, node)
+            }
+            is PtLabel -> {
+                StNode(node.name, StNodeType.LABEL, node)
+            }
+            is PtMemMapped -> {
+                StMemVar(node.name, node.type, node.address, node.arraySize?.toInt(), node)
+            }
+            is PtSub -> {
+                val params = node.parameters.map {StSubroutineParameter(it.name, it.type) }
+                StSub(node.name, params, node.returntype, node)
+            }
+            is PtVariable -> {
+                val bss = when (node.type) {
+                    // TODO should bss be a computed property on PtVariable?
+                    DataType.STR -> false
+                    in ArrayDatatypes -> node.value==null || node.arraySize==0u
+                    else -> node.value==null
+                }
+                val initialNumeric: Double?
+                val initialString: StString?
+                val initialArray: StArray?
+                val numElements: Int?
+                val value = node.value
+                if(value!=null) {
+                    initialNumeric = (value as? PtNumber)?.number
+                    when (value) {
+                        is PtString -> {
+                            initialString = StString(value.value, value.encoding)
+                            initialArray = null
+                            numElements = value.value.length + 1   // include the terminating 0-byte
+                        }
+                        is PtArray -> {
+                            initialArray = makeInitialArray(value)
+                            initialString = null
+                            numElements = initialArray.size
+                            require(node.arraySize?.toInt()==numElements)
+                        }
+                        else -> {
+                            initialString = null
+                            initialArray = null
+                            numElements = node.arraySize?.toInt()
+                        }
+                    }
+                } else {
+                    initialNumeric = null
+                    initialArray = null
+                    initialString = null
+                    numElements = node.arraySize?.toInt()
+                }
+                StStaticVariable(node.name, node.type, bss, initialNumeric, initialString, initialArray, numElements, node.zeropage, node)
+            }
+            is PtBuiltinFunctionCall -> {
+                if(node.name=="memory") {
+                    // memory slab allocations are a builtin functioncall in the program, but end up named as well in the symboltable
+                    require(node.name.all { it.isLetterOrDigit() || it=='_' }) {"memory name should be a valid symbol name"}
+                    val slabname = (node.args[0] as PtString).value
+                    val size = (node.args[1] as PtNumber).number.toUInt()
+                    val align = (node.args[2] as PtNumber).number.toUInt()
+                    // don't add memory slabs in nested scope, just put them in the top level of the ST
+                    scope.firstElement().add(StMemorySlab("prog8_memoryslab_$slabname", size, align, node))
+                }
+                null
+            }
+            else -> null // node is not present in the ST
+        }
+
+        if(stNode!=null) {
+            scope.peek().add(stNode)
+            scope.push(stNode)
+        }
+        node.children.forEach {
+            addToSt(it, scope)
+        }
+        if(stNode!=null)
+            scope.pop()
+    }
+
+    private fun makeInitialArray(value: PtArray): List<StArrayElement> {
+        return value.children.map {
+            when(it) {
+                is PtAddressOf -> StArrayElement(null, it.identifier.name)
+                is PtIdentifier -> StArrayElement(null, it.name)
+                is PtNumber -> StArrayElement(it.number, null)
+                else -> throw AssemblyError("invalid array element $it")
+            }
+        }
+    }
+
+}
+
+//    override fun visit(decl: VarDecl) {
+//        val node =
+//            when(decl.type) {
+//                VarDeclType.VAR -> {
+//                    var initialNumeric = (decl.value as? NumericLiteral)?.number
+//                    if(initialNumeric==0.0)
+//                        initialNumeric=null     // variable will go into BSS and this will be set to 0
+//                    val initialStringLit = decl.value as? StringLiteral
+//                    val initialString = if(initialStringLit==null) null else Pair(initialStringLit.value, initialStringLit.encoding)
+//                    val initialArrayLit = decl.value as? ArrayLiteral
+//                    val initialArray = makeInitialArray(initialArrayLit)
+//                    if(decl.isArray && decl.datatype !in ArrayDatatypes)
+//                        throw FatalAstException("array vardecl has mismatched dt ${decl.datatype}")
+//                    val numElements =
+//                        if(decl.isArray)
+//                            decl.arraysize!!.constIndex()
+//                        else if(initialStringLit!=null)
+//                            initialStringLit.value.length+1  // include the terminating 0-byte
+//                        else
+//                            null
+//                    val bss = if(decl.datatype==DataType.STR)
+//                        false
+//                    else if(decl.isArray)
+//                        initialArray.isNullOrEmpty()
+//                    else
+//                        initialNumeric == null
+//                    val astNode = PtVariable(decl.name, decl.datatype, null, null, decl.position)
+//                    StStaticVariable(decl.name, decl.datatype, bss, initialNumeric, initialString, initialArray, numElements, decl.zeropage, astNode, decl.position)
+//                }
+//                VarDeclType.CONST -> {
+//                    val astNode = PtVariable(decl.name, decl.datatype, null, null, decl.position)
+//                    StConstant(decl.name, decl.datatype, (decl.value as NumericLiteral).number, astNode, decl.position)
+//                }
+//                VarDeclType.MEMORY -> {
+//                    val numElements =
+//                        if(decl.datatype in ArrayDatatypes)
+//                            decl.arraysize!!.constIndex()
+//                        else null
+//                    val astNode = PtVariable(decl.name, decl.datatype, null, null, decl.position)
+//                    StMemVar(decl.name, decl.datatype, (decl.value as NumericLiteral).number.toUInt(), numElements, astNode, decl.position)
+//                }
+//            }
+//        scopestack.peek().add(node)
+//        // st.origAstLinks[decl] = node
+//    }
+//
+//    private fun makeInitialArray(arrayLit: ArrayLiteral?): StArray? {
+//        if(arrayLit==null)
+//            return null
+//        return arrayLit.value.map {
+//            when(it){
+//                is AddressOf -> {
+//                    val scopedName = it.identifier.targetNameAndType(program).first
+//                    StArrayElement(null, scopedName)
+//                }
+//                is IdentifierReference -> {
+//                    val scopedName = it.targetNameAndType(program).first
+//                    StArrayElement(null, scopedName)
+//                }
+//                is NumericLiteral -> StArrayElement(it.number, null)
+//                else -> throw FatalAstException("weird element dt in array literal")
+//            }
+//        }.toList()
+//    }
+//

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

@@ -3,6 +3,7 @@ package prog8.code.ast
 import prog8.code.core.IMemSizer
 import prog8.code.core.IStringEncoding
 import prog8.code.core.Position
+import prog8.code.core.SourceCode
 import java.nio.file.Path
 
 // New simplified AST for the code generator.
@@ -13,16 +14,6 @@ sealed class PtNode(val position: Position) {
     val children = mutableListOf<PtNode>()
     lateinit var parent: PtNode
 
-    fun printIndented(indent: Int) {
-        print("    ".repeat(indent))
-        print("${this.javaClass.simpleName}  ")
-        printProperties()
-        println()
-        children.forEach { it.printIndented(indent+1) }
-    }
-
-    abstract fun printProperties()
-
     fun add(child: PtNode) {
         children.add(child)
         child.parent = this
@@ -36,12 +27,11 @@ sealed class PtNode(val position: Position) {
     fun definingBlock() = findParentNode<PtBlock>(this)
     fun definingSub() = findParentNode<PtSub>(this)
     fun definingAsmSub() = findParentNode<PtAsmSub>(this)
+    fun definingISub() = findParentNode<IPtSubroutine>(this)
 }
 
 
-class PtNodeGroup : PtNode(Position.DUMMY) {
-    override fun printProperties() {}
-}
+class PtNodeGroup : PtNode(Position.DUMMY)
 
 
 sealed class PtNamedNode(var name: String, position: Position): PtNode(position) {
@@ -65,10 +55,6 @@ class PtProgram(
     val memsizer: IMemSizer,
     val encoding: IStringEncoding
 ) : PtNode(Position.DUMMY) {
-    fun print() = printIndented(0)
-    override fun printProperties() {
-        print("'$name'")
-    }
 
 //    fun allModuleDirectives(): Sequence<PtDirective> =
 //        children.asSequence().flatMap { it.children }.filterIsInstance<PtDirective>().distinct()
@@ -86,12 +72,9 @@ class PtBlock(name: String,
               val library: Boolean,
               val forceOutput: Boolean,
               val alignment: BlockAlignment,
+              val source: SourceCode,       // taken from the module the block is defined in.
               position: Position
 ) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print("$name  addr=$address  library=$library  forceOutput=$forceOutput  alignment=$alignment")
-    }
-
     enum class BlockAlignment {
         NONE,
         WORD,
@@ -101,8 +84,6 @@ class PtBlock(name: String,
 
 
 class PtInlineAssembly(val assembly: String, val isIR: Boolean, position: Position) : PtNode(position) {
-    override fun printProperties() {}
-
     init {
         require(!assembly.startsWith('\n') && !assembly.startsWith('\r')) { "inline assembly should be trimmed" }
         require(!assembly.endsWith('\n') && !assembly.endsWith('\r')) { "inline assembly should be trimmed" }
@@ -110,28 +91,16 @@ class PtInlineAssembly(val assembly: String, val isIR: Boolean, position: Positi
 }
 
 
-class PtLabel(name: String, position: Position) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print(name)
-    }
-}
+class PtLabel(name: String, position: Position) : PtNamedNode(name, position)
 
 
-class PtBreakpoint(position: Position): PtNode(position) {
-    override fun printProperties() {}
-}
+class PtBreakpoint(position: Position): PtNode(position)
 
 
-class PtIncludeBinary(val file: Path, val offset: UInt?, val length: UInt?, position: Position) : PtNode(position) {
-    override fun printProperties() {
-        print("filename=$file  offset=$offset  length=$length")
-    }
-}
+class PtIncludeBinary(val file: Path, val offset: UInt?, val length: UInt?, position: Position) : PtNode(position)
 
 
-class PtNop(position: Position): PtNode(position) {
-    override fun printProperties() {}
-}
+class PtNop(position: Position): PtNode(position)
 
 
 // find the parent node of a specific type or interface

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

@@ -1,8 +1,6 @@
 package prog8.code.ast
 
-import prog8.code.core.DataType
-import prog8.code.core.Encoding
-import prog8.code.core.Position
+import prog8.code.core.*
 import java.util.*
 import kotlin.math.round
 
@@ -23,10 +21,6 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
         }
     }
 
-    override fun printProperties() {
-        print(type)
-    }
-
     infix fun isSameAs(other: PtExpression): Boolean {
         return when(this) {
             is PtAddressOf -> other is PtAddressOf && other.type==type && other.identifier isSameAs identifier
@@ -43,6 +37,21 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
             else -> false
         }
     }
+
+    infix fun isSameAs(target: PtAssignTarget): Boolean {
+        return when {
+            target.memory != null && this is PtMemoryByte-> {
+                target.memory!!.address isSameAs this.address
+            }
+            target.identifier != null && this is PtIdentifier -> {
+                this.name == target.identifier!!.name
+            }
+            target.array != null && this is PtArrayIndexer -> {
+                this.variable.name == target.array!!.variable.name && this.index isSameAs target.array!!.index
+            }
+            else -> false
+        }
+    }
 }
 
 class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
@@ -51,11 +60,15 @@ class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
 }
 
 
-class PtArrayIndexer(type: DataType, position: Position): PtExpression(type, position) {
+class PtArrayIndexer(elementType: DataType, position: Position): PtExpression(elementType, position) {
     val variable: PtIdentifier
         get() = children[0] as PtIdentifier
     val index: PtExpression
         get() = children[1] as PtExpression
+
+    init {
+        require(elementType in NumericDatatypes)
+    }
 }
 
 
@@ -66,6 +79,9 @@ class PtArray(type: DataType, position: Position): PtExpression(type, position)
             return false
         return type==other.type && children == other.children
     }
+
+    val size: Int
+        get() = children.size
 }
 
 
@@ -81,9 +97,6 @@ class PtBuiltinFunctionCall(val name: String,
 
     val args: List<PtExpression>
         get() = children.map { it as PtExpression }
-    override fun printProperties() {
-        print("$name void=$void noSideFx=$hasNoSideEffects")
-    }
 }
 
 
@@ -93,10 +106,6 @@ class PtBinaryExpression(val operator: String, type: DataType, position: Positio
         get() = children[0] as PtExpression
     val right: PtExpression
         get() = children[1] as PtExpression
-
-    override fun printProperties() {
-        print("$operator -> $type")
-    }
 }
 
 
@@ -119,28 +128,25 @@ class PtFunctionCall(val name: String,
 
     val args: List<PtExpression>
         get() = children.map { it as PtExpression }
-    override fun printProperties() {
-        print("$name void=$void")
-    }
 }
 
 
-class PtIdentifier(val name: String, type: DataType, position: Position) : PtExpression(type, position) {
-    override fun printProperties() {
-        print("$name  $type")
-    }
-}
+class PtIdentifier(val name: String, type: DataType, position: Position) : PtExpression(type, position)
 
 
 class PtMemoryByte(position: Position) : PtExpression(DataType.UBYTE, position) {
     val address: PtExpression
         get() = children.single() as PtExpression
-    override fun printProperties() {}
 }
 
 
 class PtNumber(type: DataType, val number: Double, position: Position) : PtExpression(type, position) {
 
+    companion object {
+        fun fromBoolean(bool: Boolean, position: Position): PtNumber =
+            PtNumber(DataType.UBYTE, if(bool) 1.0 else 0.0, position)
+    }
+
     init {
         if(type==DataType.BOOL)
             throw IllegalArgumentException("bool should have become ubyte @$position")
@@ -151,10 +157,6 @@ class PtNumber(type: DataType, val number: Double, position: Position) : PtExpre
         }
     }
 
-    override fun printProperties() {
-        print("$number ($type)")
-    }
-
     override fun hashCode(): Int = Objects.hash(type, number)
 
     override fun equals(other: Any?): Boolean {
@@ -175,10 +177,6 @@ class PtPrefix(val operator: String, type: DataType, position: Position): PtExpr
         // note: the "not" operator may no longer occur in the ast; not x should have been replaced with x==0
         require(operator in setOf("+", "-", "~")) { "invalid prefix operator: $operator" }
     }
-
-    override fun printProperties() {
-        print(operator)
-    }
 }
 
 
@@ -189,16 +187,10 @@ class PtRange(type: DataType, position: Position) : PtExpression(type, position)
         get() = children[1] as PtExpression
     val step: PtNumber
         get() = children[2] as PtNumber
-
-    override fun printProperties() {}
 }
 
 
 class PtString(val value: String, val encoding: Encoding, position: Position) : PtExpression(DataType.STR, position) {
-    override fun printProperties() {
-        print("$encoding:\"$value\"")
-    }
-
     override fun hashCode(): Int = Objects.hash(value, encoding)
     override fun equals(other: Any?): Boolean {
         if(other==null || other !is PtString)
@@ -214,12 +206,8 @@ class PtTypeCast(type: DataType, position: Position) : PtExpression(type, positi
 }
 
 
-// special node that isn't created from compiling user code, but used internally
-class PtMachineRegister(val register: Int, type: DataType, position: Position) : PtExpression(type, position) {
-    override fun printProperties() {
-        print("reg=$register  $type")
-    }
-}
+// special node that isn't created from compiling user code, but used internally in the Intermediate Code
+class PtMachineRegister(val register: Int, type: DataType, position: Position) : PtExpression(type, position)
 
 
 fun constValue(expr: PtExpression): Double? = if(expr is PtNumber) expr.number else null

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

@@ -57,7 +57,7 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
             is PtAsmSub -> {
                 val params = if (node.parameters.isEmpty()) "" else "...TODO ${node.parameters.size} PARAMS..."
                 val clobbers = if (node.clobbers.isEmpty()) "" else "clobbers ${node.clobbers}"
-                val returns = if (node.returnTypes.isEmpty()) "" else (if (node.returnTypes.size == 1) "-> ${node.returnTypes[0].name.lowercase()}" else "-> ${node.returnTypes.map { it.name.lowercase() }}")
+                val returns = if (node.returns.isEmpty()) "" else (if (node.returns.size == 1) "-> ${node.returns[0].second.name.lowercase()}" else "-> ${node.returns.map { it.second.name.lowercase() }}")
                 val str = if (node.inline) "inline " else ""
                 if(node.address==null) {
                     str + "asmsub ${node.name}($params) $clobbers $returns"
@@ -66,7 +66,7 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
                 }
             }
             is PtBlock -> {
-                val addr = if(node.address==null) "" else "@${node.address?.toHex()}"
+                val addr = if(node.address==null) "" else "@${node.address.toHex()}"
                 val align = if(node.alignment==PtBlock.BlockAlignment.NONE) "" else "align=${node.alignment}"
                 "\nblock '${node.name}' $addr $align"
             }
@@ -86,8 +86,7 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
             }
             is PtSub -> {
                 val params = if (node.parameters.isEmpty()) "" else "...TODO ${node.parameters.size} PARAMS..."
-                var str = if(node.inline) "inline " else ""
-                str += "sub ${node.name}($params) "
+                var str = "sub ${node.name}($params) "
                 if(node.returntype!=null)
                     str += "-> ${node.returntype.name.lowercase()}"
                 str
@@ -104,7 +103,7 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
                 else
                     "${node.type.name.lowercase()} ${node.name}"
                 if(node.value!=null)
-                    str + " = " + txt(node.value!!)
+                    str + " = " + txt(node.value)
                 else
                     str
             }
@@ -135,6 +134,7 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
                     output("    ".repeat(depth) + txt(node))
             }
         }
+        println()
     } else {
         walkAst(root) { node, depth ->
             val txt = txt(node)

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

@@ -3,48 +3,39 @@ package prog8.code.ast
 import prog8.code.core.*
 
 
+sealed interface IPtSubroutine {
+    val name: String
+}
+
 class PtAsmSub(
     name: String,
     val address: UInt?,
     val clobbers: Set<CpuRegister>,
-    val parameters: List<Pair<PtSubroutineParameter, RegisterOrStatusflag>>,
-    val returnTypes: List<DataType>,    // TODO join with register as Pairs ?
-    val retvalRegisters: List<RegisterOrStatusflag>,
+    val parameters: List<Pair<RegisterOrStatusflag, PtSubroutineParameter>>,
+    val returns: List<Pair<RegisterOrStatusflag, DataType>>,
     val inline: Boolean,
     position: Position
-) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print("$name  inline=$inline")
-    }
-}
+) : PtNamedNode(name, position), IPtSubroutine
 
 
 class PtSub(
     name: String,
     val parameters: List<PtSubroutineParameter>,
     val returntype: DataType?,
-    val inline: Boolean,
     position: Position
-) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print(name)
-    }
-
+) : PtNamedNode(name, position), IPtSubroutine {
     init {
         // params and return value should not be str
         if(parameters.any{ it.type !in NumericDatatypes })
             throw AssemblyError("non-numeric parameter")
         if(returntype!=null && returntype !in NumericDatatypes)
             throw AssemblyError("non-numeric returntype $returntype")
+        parameters.forEach { it.parent=this }
     }
 }
 
 
-class PtSubroutineParameter(val name: String, val type: DataType, position: Position): PtNode(position) {
-    override fun printProperties() {
-        print("$type $name")
-    }
-}
+class PtSubroutineParameter(name: String, val type: DataType, position: Position): PtNamedNode(name, position)
 
 
 class PtAssignment(position: Position) : PtNode(position) {
@@ -53,8 +44,6 @@ class PtAssignment(position: Position) : PtNode(position) {
     val value: PtExpression
         get() = children[1] as PtExpression
 
-    override fun printProperties() { }
-
     val isInplaceAssign: Boolean by lazy {
         val target = target.children.single() as PtExpression
         when(val source = value) {
@@ -102,7 +91,7 @@ class PtAssignTarget(position: Position) : PtNode(position) {
             }
         }
 
-    override fun printProperties() {}
+    infix fun isSameAs(expression: PtExpression): Boolean = expression.isSameAs(this)
 }
 
 
@@ -111,10 +100,6 @@ class PtConditionalBranch(val condition: BranchCondition, position: Position) :
         get() = children[0] as PtNodeGroup
     val falseScope: PtNodeGroup
         get() = children[1] as PtNodeGroup
-
-    override fun printProperties() {
-        print(condition)
-    }
 }
 
 
@@ -125,8 +110,6 @@ class PtForLoop(position: Position) : PtNode(position) {
         get() = children[1] as PtExpression
     val statements: PtNodeGroup
         get() = children[2] as PtNodeGroup
-
-    override fun printProperties() {}
 }
 
 
@@ -137,8 +120,6 @@ class PtIfElse(position: Position) : PtNode(position) {
         get() = children[1] as PtNodeGroup
     val elseScope: PtNodeGroup
         get() = children[2] as PtNodeGroup
-
-    override fun printProperties() {}
 }
 
 
@@ -146,10 +127,8 @@ class PtJump(val identifier: PtIdentifier?,
              val address: UInt?,
              val generatedLabel: String?,
              position: Position) : PtNode(position) {
-    override fun printProperties() {
-        identifier?.printProperties()
-        if(address!=null) print(address.toHex())
-        if(generatedLabel!=null) print(generatedLabel)
+    init {
+        identifier?.let {it.parent = this }
     }
 }
 
@@ -157,10 +136,6 @@ class PtJump(val identifier: PtIdentifier?,
 class PtPostIncrDecr(val operator: String, position: Position) : PtNode(position) {
     val target: PtAssignTarget
         get() = children.single() as PtAssignTarget
-
-    override fun printProperties() {
-        print(operator)
-    }
 }
 
 
@@ -169,8 +144,6 @@ class PtRepeatLoop(position: Position) : PtNode(position) {
         get() = children[0] as PtExpression
     val statements: PtNodeGroup
         get() = children[1] as PtNodeGroup
-
-    override fun printProperties() {}
 }
 
 
@@ -183,30 +156,26 @@ class PtReturn(position: Position) : PtNode(position) {
             else
                 null
         }
-
-    override fun printProperties() {}
 }
 
 
-class PtVariable(name: String, val type: DataType, var value: PtExpression?, var arraySize: UInt?, position: Position) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print("$type  $name")
+sealed interface IPtVariable {
+    val name: String
+    val type: DataType
+}
+
+
+class PtVariable(name: String, override val type: DataType, val zeropage: ZeropageWish, val value: PtExpression?, val arraySize: UInt?, position: Position) : PtNamedNode(name, position), IPtVariable {
+    init {
+        value?.let {it.parent=this}
     }
 }
 
 
-class PtConstant(name: String, val type: DataType, val value: Double, position: Position) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print("$type $name = $value")
-    }
-}
+class PtConstant(name: String, override val type: DataType, val value: Double, position: Position) : PtNamedNode(name, position), IPtVariable
 
 
-class PtMemMapped(name: String, val type: DataType, val address: UInt, val arraySize: UInt?, position: Position) : PtNamedNode(name, position) {
-    override fun printProperties() {
-        print("&$type $name = ${address.toHex()}")
-    }
-}
+class PtMemMapped(name: String, override val type: DataType, val address: UInt, val arraySize: UInt?, position: Position) : PtNamedNode(name, position), IPtVariable
 
 
 class PtWhen(position: Position) : PtNode(position) {
@@ -214,8 +183,6 @@ class PtWhen(position: Position) : PtNode(position) {
         get() = children[0] as PtExpression
     val choices: PtNodeGroup
         get() = children[1] as PtNodeGroup
-
-    override fun printProperties() {}
 }
 
 
@@ -224,5 +191,4 @@ class PtWhenChoice(val isElse: Boolean, position: Position) : PtNode(position) {
         get() = children[0] as PtNodeGroup
     val statements: PtNodeGroup
         get() = children[1] as PtNodeGroup
-    override fun printProperties() {}
 }

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

@@ -0,0 +1,111 @@
+package prog8.code.core
+
+class ReturnConvention(val dt: DataType?, val reg: RegisterOrPair?, val floatFac1: Boolean)
+class ParamConvention(val dt: DataType, val reg: RegisterOrPair?, val variable: Boolean)
+class CallConvention(val params: List<ParamConvention>, val returns: ReturnConvention) {
+    override fun toString(): String {
+        val paramConvs =  params.mapIndexed { index, it ->
+            when {
+                it.reg!=null -> "$index:${it.reg}"
+                it.variable -> "$index:variable"
+                else -> "$index:???"
+            }
+        }
+        val returnConv =
+            when {
+                returns.reg!=null -> returns.reg.toString()
+                returns.floatFac1 -> "floatFAC1"
+                else -> "<no returnvalue>"
+            }
+        return "CallConvention[" + paramConvs.joinToString() + " ; returns: $returnConv]"
+    }
+}
+
+class FParam(val name: String, val possibleDatatypes: Array<DataType>)
+
+class FSignature(val pure: Boolean,      // does it have side effects?
+                      val parameters: List<FParam>,
+                      val returnType: DataType?) {
+
+    fun callConvention(actualParamTypes: List<DataType>): CallConvention {
+        val returns: ReturnConvention = when (returnType) {
+            DataType.UBYTE, DataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A, false)
+            DataType.UWORD, DataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY, false)
+            DataType.FLOAT -> ReturnConvention(returnType, null, true)
+            in PassByReferenceDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY, false)
+            null -> ReturnConvention(null, null, false)
+            else -> {
+                // return type depends on arg type
+                when (val paramType = actualParamTypes.first()) {
+                    DataType.UBYTE, DataType.BYTE -> ReturnConvention(paramType, RegisterOrPair.A, false)
+                    DataType.UWORD, DataType.WORD -> ReturnConvention(paramType, RegisterOrPair.AY, false)
+                    DataType.FLOAT -> ReturnConvention(paramType, null, true)
+                    in PassByReferenceDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY, false)
+                    else -> ReturnConvention(paramType, null, false)
+                }
+            }
+        }
+
+        return when {
+            actualParamTypes.isEmpty() -> CallConvention(emptyList(), returns)
+            actualParamTypes.size==1 -> {
+                // one parameter goes via register/registerpair
+                val paramConv = when(val paramType = actualParamTypes[0]) {
+                    DataType.UBYTE, DataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false)
+                    DataType.UWORD, DataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    DataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    in PassByReferenceDatatypes -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    else -> ParamConvention(paramType, null, false)
+                }
+                CallConvention(listOf(paramConv), returns)
+            }
+            else -> {
+                // multiple parameters go via variables
+                val paramConvs = actualParamTypes.map { ParamConvention(it, null, true) }
+                CallConvention(paramConvs, returns)
+            }
+        }
+    }
+}
+
+
+val BuiltinFunctions: Map<String, FSignature> = mapOf(
+    // this set of function have no return value and operate in-place:
+    "rol"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
+    "rol2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
+    "sort"      to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
+    "reverse"   to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
+    // cmp returns a status in the carry flag, but not a proper return value
+    "cmp"       to FSignature(false, listOf(FParam("value1", IntegerDatatypesNoBool), FParam("value2", NumericDatatypesNoBool)), null),
+    "abs"       to FSignature(true, listOf(FParam("value", IntegerDatatypesNoBool)), DataType.UWORD),
+    "len"       to FSignature(true, listOf(FParam("values", IterableDatatypes)), DataType.UWORD),
+    // normal functions follow:
+    "sizeof"    to FSignature(true, listOf(FParam("object", DataType.values())), DataType.UBYTE),
+    "sgn"       to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), DataType.BYTE),
+    "sqrt16"    to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD))), DataType.UBYTE),
+    "any"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE),
+    "all"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE),
+    "lsb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),
+    "msb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),
+    "mkword"    to FSignature(true, listOf(FParam("msb", arrayOf(DataType.UBYTE)), FParam("lsb", arrayOf(DataType.UBYTE))), DataType.UWORD),
+    "peek"      to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UBYTE),
+    "peekw"     to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "poke"      to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
+    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
+    "pokew"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UWORD))), null),
+    "pop"       to FSignature(false, listOf(FParam("target", ByteDatatypes)), null),
+    "popw"      to FSignature(false, listOf(FParam("target", WordDatatypes)), null),
+    "push"      to FSignature(false, listOf(FParam("value", ByteDatatypes)), null),
+    "pushw"     to FSignature(false, listOf(FParam("value", WordDatatypes)), null),
+    "rsave"     to FSignature(false, emptyList(), null),
+    "rsavex"    to FSignature(false, emptyList(), null),
+    "rrestore"  to FSignature(false, emptyList(), null),
+    "rrestorex" to FSignature(false, emptyList(), null),
+    "memory"    to FSignature(true, listOf(FParam("name", arrayOf(DataType.STR)), FParam("size", arrayOf(DataType.UWORD)), FParam("alignment", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "callfar"   to FSignature(false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), null),
+    "callrom"   to FSignature(false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), null),
+)
+
+val InplaceModifyingBuiltinFunctions = setOf("rol", "ror", "rol2", "ror2", "sort", "reverse")

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

@@ -23,4 +23,8 @@ class CompilationOptions(val output: OutputType,
                          var evalStackBaseAddress: UInt? = null,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()
-)
+) {
+    init {
+        compTarget.machine.initializeMemoryAreas(this)
+    }
+}

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

@@ -1,12 +0,0 @@
-package prog8.code.core
-
-interface IAssemblyGenerator {
-    fun compileToAssembly(): IAssemblyProgram?
-}
-
-interface IAssemblyProgram {
-    val name: String
-    fun assemble(options: CompilationOptions): Boolean
-}
-
-fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"

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

@@ -0,0 +1,19 @@
+package prog8.code.core
+
+import prog8.code.SymbolTable
+import prog8.code.ast.PtProgram
+
+interface ICodeGeneratorBackend {
+    fun generate(program: PtProgram,
+                 symbolTable: SymbolTable,
+                 options: CompilationOptions,
+                 errors: IErrorReporter): IAssemblyProgram?
+}
+
+
+interface IAssemblyProgram {
+    val name: String
+    fun assemble(options: CompilationOptions): Boolean
+}
+
+fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"

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

@@ -7,5 +7,5 @@ interface ICompilationTarget: IStringEncoding, IMemSizer {
     val defaultEncoding: Encoding
 
     override fun encodeString(str: String, encoding: Encoding): List<UByte>
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String
 }

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

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

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

@@ -23,7 +23,7 @@ object Encoder: IStringEncoding {
             success = { it }
         )
     }
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
         val decoded = when(encoding) {
             Encoding.PETSCII -> PetsciiEncoding.decodePetscii(bytes, true)
             Encoding.SCREENCODES -> PetsciiEncoding.decodeScreencode(bytes, true)

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

@@ -208,7 +208,7 @@ object AtasciiEncoding {
         return Ok(mapped)
     }
 
-    fun decode(bytes: List<UByte>): Result<String, CharConversionException> {
+    fun decode(bytes: Iterable<UByte>): Result<String, CharConversionException> {
         return Ok(bytes.map { decodeTable[it.toInt()] }.joinToString(""))
     }
 }

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

@@ -27,7 +27,7 @@ object IsoEncoding {
         }
     }
 
-    fun decode(bytes: List<UByte>): Result<String, CharConversionException> {
+    fun decode(bytes: Iterable<UByte>): Result<String, CharConversionException> {
         return try {
             Ok(String(bytes.map { it.toByte() }.toByteArray(), charset))
         } catch (ce: CharConversionException) {

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

@@ -44,9 +44,24 @@ class VirtualMachineDefinition: IMachineDefinition {
 
     override fun isIOAddress(address: UInt): Boolean = false
 
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {}
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = VirtualZeropage(compilerOptions)
+    }
 }
 
 interface IVirtualMachineRunner {
     fun runProgram(irSource: String)
 }
+
+private class VirtualZeropage(options: CompilationOptions): Zeropage(options) {
+    override val SCRATCH_B1: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_REG: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_W1: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_W2: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+
+    override fun allocateCx16VirtualRegisters() { /* there is no actual zero page in this target to allocate thing in */ }
+}

codeGenCpu6502/build.gradle

@@ -3,6 +3,7 @@ plugins {
     id 'java'
     id 'application'
     id "org.jetbrains.kotlin.jvm"
+    id "io.kotest" version "0.3.9"
 }
 
 java {
@@ -25,11 +26,11 @@ compileTestKotlin {
 
 dependencies {
     implementation project(':codeCore')
-    implementation project(':compilerAst')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
 
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
 }
 
 sourceSets {
@@ -41,6 +42,22 @@ sourceSets {
             srcDirs = ["${project.projectDir}/res"]
         }
     }
+    test {
+        java {
+            srcDir "${project.projectDir}/test"
+        }
+    }
 }
 
-// note: there are no unit tests in this module!
+test {
+    // Enable JUnit 5 (Gradle 4.6+).
+    useJUnitPlatform()
+
+    // Always run tests, even when nothing changed.
+    dependsOn 'cleanTest'
+
+    // Show test results.
+    testLogging {
+        events "skipped", "failed"
+    }
+}

codeGenCpu6502/codeGenCpu6502.iml

@@ -4,13 +4,15 @@
     <exclude-output />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/build" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="module" module-name="codeCore" />
-    <orderEntry type="module" module-name="compilerAst" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
+    <orderEntry type="library" name="io.kotest.assertions.core.jvm" level="project" />
+    <orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
   </component>
 </module>

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

@@ -1,16 +1,15 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.Program
-import prog8.ast.expressions.NumericLiteral
-import prog8.ast.statements.VarDecl
-import prog8.ast.statements.VarDeclType
+import prog8.code.StConstant
+import prog8.code.StMemVar
+import prog8.code.SymbolTable
 import prog8.code.core.IMachineDefinition
 
 
 // note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations
 
 
-internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefinition, program: Program): Int {
+internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefinition, symbolTable: SymbolTable): Int {
 
     var numberOfOptimizations = 0
 
@@ -37,7 +36,7 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
-    mods = optimizeStoreLoadSame(linesByFour, machine, program)
+    mods = optimizeStoreLoadSame(linesByFour, machine, symbolTable)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
@@ -52,14 +51,14 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
     }
 
     var linesByFourteen = getLinesBy(lines, 14)
-    mods = optimizeSameAssignments(linesByFourteen, machine, program)
+    mods = optimizeSameAssignments(linesByFourteen, machine, symbolTable)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFourteen = getLinesBy(lines, 14)
         numberOfOptimizations++
     }
 
-    mods = optimizeSamePointerIndexing(linesByFourteen, machine, program)
+    mods = optimizeSamePointerIndexing(linesByFourteen)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFourteen = getLinesBy(lines, 14)
@@ -129,7 +128,11 @@ private fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<S
     return mods
 }
 
-private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>, machine: IMachineDefinition, program: Program): List<Modification> {
+private fun optimizeSameAssignments(
+    linesByFourteen: List<List<IndexedValue<String>>>,
+    machine: IMachineDefinition,
+    symbolTable: SymbolTable
+): List<Modification> {
 
     // Optimize sequential assignments of the same value to various targets (bytes, words, floats)
     // the float one is the one that requires 2*7=14 lines of code to check...
@@ -154,8 +157,8 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
             val fourthvalue = sixth.substring(4)
             if(firstvalue==thirdvalue && secondvalue==fourthvalue) {
                 // lda/ldy   sta/sty   twice the same word -->  remove second lda/ldy pair (fifth and sixth lines)
-                val address1 = getAddressArg(first, program)
-                val address2 = getAddressArg(second, program)
+                val address1 = getAddressArg(first, symbolTable)
+                val address2 = getAddressArg(second, symbolTable)
                 if(address1==null || address2==null || (!machine.isIOAddress(address1) && !machine.isIOAddress(address2))) {
                     mods.add(Modification(lines[4].index, true, null))
                     mods.add(Modification(lines[5].index, true, null))
@@ -168,7 +171,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
             val secondvalue = third.substring(4)
             if(firstvalue==secondvalue) {
                 // lda value / sta ? / lda same-value / sta ?  -> remove second lda (third line)
-                val address = getAddressArg(first, program)
+                val address = getAddressArg(first, symbolTable)
                 if(address==null || !machine.isIOAddress(address))
                     mods.add(Modification(lines[2].index, true, null))
             }
@@ -251,7 +254,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
                 val thirdvalue = third.substring(4)
                 val fourthvalue = fourth.substring(4)
                 if(firstvalue==thirdvalue && secondvalue == fourthvalue) {
-                    val address = getAddressArg(first, program)
+                    val address = getAddressArg(first, symbolTable)
                     if(address==null || !machine.isIOAddress(address)) {
                         overlappingMods = true
                         mods.add(Modification(lines[2].index, true, null))
@@ -275,7 +278,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
                 val firstvalue = first.substring(4)
                 val thirdvalue = third.substring(4)
                 if(firstvalue==thirdvalue) {
-                    val address = getAddressArg(first, program)
+                    val address = getAddressArg(first, symbolTable)
                     if(address==null || !machine.isIOAddress(address)) {
                         overlappingMods = true
                         mods.add(Modification(lines[2].index, true, null))
@@ -295,7 +298,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
             val secondvalue = second.substring(4)
             val thirdvalue = third.substring(4)
             if(firstvalue==secondvalue && firstvalue==thirdvalue) {
-                val address = getAddressArg(first, program)
+                val address = getAddressArg(first, symbolTable)
                 if(address==null || !machine.isIOAddress(address)) {
                     overlappingMods = true
                     val reg2 = second[2]
@@ -314,7 +317,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
                 val firstvalue = first.substring(4)
                 val secondvalue = second.substring(4)
                 if(firstvalue==secondvalue) {
-                    val address = getAddressArg(first, program)
+                    val address = getAddressArg(first, symbolTable)
                     if(address==null || !machine.isIOAddress(address)) {
                         overlappingMods = true
                         mods.add(Modification(lines[0].index, true, null))
@@ -327,7 +330,7 @@ private fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<Stri
     return mods
 }
 
-private fun optimizeSamePointerIndexing(linesByFourteen: List<List<IndexedValue<String>>>, machine: IMachineDefinition, program: Program): List<Modification> {
+private fun optimizeSamePointerIndexing(linesByFourteen: List<List<IndexedValue<String>>>): List<Modification> {
 
     // Optimize same pointer indexing where for instance we load and store to the same ptr index in Y
     // if Y isn't modified in between we can omit the second LDY:
@@ -369,7 +372,11 @@ private fun optimizeSamePointerIndexing(linesByFourteen: List<List<IndexedValue<
     return mods
 }
 
-private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>, machine: IMachineDefinition, program: Program): List<Modification> {
+private fun optimizeStoreLoadSame(
+    linesByFour: List<List<IndexedValue<String>>>,
+    machine: IMachineDefinition,
+    symbolTable: SymbolTable
+): List<Modification> {
     // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can OFTEN be eliminated
     val mods = mutableListOf<Modification>()
     for (lines in linesByFour) {
@@ -397,7 +404,7 @@ private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>,
                 }
                 else {
                     // no branch instruction follows, we can remove the load instruction
-                    val address = getAddressArg(lines[2].value, program)
+                    val address = getAddressArg(lines[2].value, symbolTable)
                     address==null || !machine.isIOAddress(address)
                 }
 
@@ -439,7 +446,8 @@ private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>,
 
 private val identifierRegex = Regex("""^([a-zA-Z_$][a-zA-Z\d_\.$]*)""")
 
-private fun getAddressArg(line: String, program: Program): UInt? {
+private fun getAddressArg(line: String, symbolTable: SymbolTable): UInt? {
+    // try to get the constant value address, could return null if it's a symbol instead
     val loadArg = line.trimStart().substring(3).trim()
     return when {
         loadArg.startsWith('$') -> loadArg.substring(1).toUIntOrNull(16)
@@ -450,15 +458,11 @@ private fun getAddressArg(line: String, program: Program): UInt? {
             val identMatch = identifierRegex.find(loadArg)
             if(identMatch!=null) {
                 val identifier = identMatch.value
-                val decl = program.toplevelModule.lookup(identifier.split('.')) as? VarDecl
-                if(decl!=null) {
-                    when(decl.type){
-                        VarDeclType.VAR -> null
-                        VarDeclType.CONST,
-                        VarDeclType.MEMORY -> (decl.value as NumericLiteral).number.toUInt()
+                when (val symbol = symbolTable.flat[identifier]) {
+                    is StConstant -> symbol.value.toUInt()
+                    is StMemVar -> symbol.address
+                    else -> null
                 }
-                }
-                else null
             } else null
         }
         else -> loadArg.substring(1).toUIntOrNull()

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

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

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

@@ -3,7 +3,6 @@ package prog8.codegen.cpu6502
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.mapError
-import prog8.ast.generatedLabelPrefix
 import prog8.code.core.*
 import java.io.File
 import java.nio.file.Path
@@ -63,7 +62,7 @@ internal class AssemblyProgram(
             "atari" -> {
                 // Atari800XL .xex generation.
 
-                // TODO are these options okay?
+                // TODO are these options okay for atari?
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
                     "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
                     "--no-monitor"
@@ -104,7 +103,7 @@ internal class AssemblyProgram(
     }
 
     private fun removeGeneratedLabelsFromMonlist() {
-        val pattern = Regex("""al (\w+) \S+${generatedLabelPrefix}.+?""")
+        val pattern = Regex("""al (\w+) \S+prog8_label_.+?""")
         val lines = viceMonListFile.toFile().readLines()
         viceMonListFile.toFile().outputStream().bufferedWriter().use {
             for (line in lines) {

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

@@ -1,49 +1,39 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.IFunctionCall
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.expressions.*
-import prog8.ast.statements.ArrayIndex
-import prog8.ast.statements.BuiltinFunctionCallStatement
-import prog8.ast.statements.Subroutine
+import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
-import prog8.compiler.BuiltinFunctions
-import prog8.compiler.FSignature
 
 
-internal class BuiltinFunctionsAsmGen(private val program: Program,
-                                      private val asmgen: AsmGen,
+internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
+                                      private val asmgen: AsmGen6502Internal,
                                       private val assignAsmGen: AssignmentAsmGen) {
 
-    internal fun translateFunctioncallExpression(fcall: BuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
-        val func = BuiltinFunctions.getValue(fcall.target.nameInSource.single())
-        translateFunctioncall(fcall, func, discardResult = false, resultToStack = resultToStack, resultRegister = resultRegister)
+    internal fun translateFunctioncallExpression(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? {
+        return translateFunctioncall(fcall, discardResult = false, resultToStack = resultToStack, resultRegister = resultRegister)
     }
 
-    internal fun translateFunctioncallStatement(fcall: BuiltinFunctionCallStatement) {
-        val func = BuiltinFunctions.getValue(fcall.name)
-        translateFunctioncall(fcall, func, discardResult = true, resultToStack = false, resultRegister = null)
+    internal fun translateFunctioncallStatement(fcall: PtBuiltinFunctionCall) {
+        translateFunctioncall(fcall, discardResult = true, resultToStack = false, resultRegister = null)
     }
 
-    private fun translateFunctioncall(fcall: IFunctionCall, func: FSignature, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
-        if (discardResult && func.pure)
-            return  // can just ignore the whole function call altogether
+    private fun translateFunctioncall(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? {
+        if (discardResult && fcall.hasNoSideEffects)
+            return null  // can just ignore the whole function call altogether
 
         if(discardResult && resultToStack)
             throw AssemblyError("cannot both discard the result AND put it onto stack")
 
-        val sscope = (fcall as Node).definingSubroutine
+        val sscope = fcall.definingISub()
 
-        when (func.name) {
+        when (fcall.name) {
             "msb" -> funcMsb(fcall, resultToStack, resultRegister)
             "lsb" -> funcLsb(fcall, resultToStack, resultRegister)
             "mkword" -> funcMkword(fcall, resultToStack, resultRegister)
-            "abs" -> funcAbs(fcall, func, resultToStack, resultRegister, sscope)
-            "any", "all" -> funcAnyAll(fcall, func, resultToStack, resultRegister, sscope)
-            "sgn" -> funcSgn(fcall, func, resultToStack, resultRegister, sscope)
-            "sqrt16" -> funcSqrt16(fcall, func, resultToStack, resultRegister, sscope)
+            "abs" -> funcAbs(fcall, resultToStack, resultRegister, sscope)
+            "any", "all" -> funcAnyAll(fcall, resultToStack, resultRegister, sscope)
+            "sgn" -> funcSgn(fcall, resultToStack, resultRegister, sscope)
+            "sqrt16" -> funcSqrt16(fcall, resultToStack, resultRegister, sscope)
             "rol" -> funcRol(fcall)
             "rol2" -> funcRol2(fcall)
             "ror" -> funcRor(fcall)
@@ -59,16 +49,20 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             "push" -> asmgen.pushCpuStack(DataType.UBYTE, fcall.args[0])
             "pushw" -> asmgen.pushCpuStack(DataType.UWORD, fcall.args[0])
             "pop" -> {
-                require(fcall.args[0] is IdentifierReference) {
-                    "attempt to pop a value into a differently typed variable, or in something else that isn't supported ${(fcall as Node).position}"
+                require(fcall.args[0] is PtIdentifier) {
+                    "attempt to pop a value into a differently typed variable, or in something else that isn't supported ${fcall.position}"
                 }
-                asmgen.popCpuStack(DataType.UBYTE, (fcall.args[0] as IdentifierReference).targetVarDecl(program)!!, (fcall as Node).definingSubroutine)
+                val symbol = asmgen.symbolTable.lookup((fcall.args[0] as PtIdentifier).name)
+                val target = symbol!!.astNode as IPtVariable
+                asmgen.popCpuStack(DataType.UBYTE, target, fcall.definingISub())
             }
             "popw" -> {
-                require(fcall.args[0] is IdentifierReference) {
-                    "attempt to pop a value into a differently typed variable, or in something else that isn't supported ${(fcall as Node).position}"
+                require(fcall.args[0] is PtIdentifier) {
+                    "attempt to pop a value into a differently typed variable, or in something else that isn't supported ${fcall.position}"
                 }
-                asmgen.popCpuStack(DataType.UWORD, (fcall.args[0] as IdentifierReference).targetVarDecl(program)!!, (fcall as Node).definingSubroutine)
+                val symbol = asmgen.symbolTable.lookup((fcall.args[0] as PtIdentifier).name)
+                val target = symbol!!.astNode as IPtVariable
+                asmgen.popCpuStack(DataType.UWORD, target, fcall.definingISub())
             }
             "rsave" -> funcRsave()
             "rsavex" -> funcRsaveX()
@@ -77,8 +71,10 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             "cmp" -> funcCmp(fcall)
             "callfar" -> funcCallFar(fcall)
             "callrom" -> funcCallRom(fcall)
-            else -> throw AssemblyError("missing asmgen for builtin func ${func.name}")
+            else -> throw AssemblyError("missing asmgen for builtin func ${fcall.name}")
         }
+
+        return BuiltinFunctions.getValue(fcall.name).returnType
     }
 
     private fun funcRsave() {
@@ -132,29 +128,29 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             asmgen.out("  sta  P8ZP_SCRATCH_B1 |  pla |  tax |  lda  P8ZP_SCRATCH_B1")
     }
 
-    private fun funcCallFar(fcall: IFunctionCall) {
+    private fun funcCallFar(fcall: PtBuiltinFunctionCall) {
         if(asmgen.options.compTarget.name != "cx16")
             throw AssemblyError("callfar only works on cx16 target at this time")
 
-        val bank = fcall.args[0].constValue(program)?.number?.toInt()
-        val address = fcall.args[1].constValue(program)?.number?.toInt() ?: 0
+        val bank = fcall.args[0].asConstInteger()
+        val address = fcall.args[1].asConstInteger() ?: 0
         val argAddrArg = fcall.args[2]
         if(bank==null)
             throw AssemblyError("callfar (jsrfar) bank has to be a constant")
-        if(fcall.args[1].constValue(program) == null) {
+        if(fcall.args[1] !is PtNumber) {
             assignAsmGen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY, false)
             asmgen.out("  sta  (+)+0 |  sty  (+)+1  ; store jsrfar address word")
         }
 
-        if(argAddrArg.constValue(program)?.number == 0.0) {
+        if(argAddrArg.asConstInteger() == 0) {
             asmgen.out("""
                 jsr  cx16.jsrfar
 +               .word  ${address.toHex()}
                 .byte  ${bank.toHex()}""")
         } else {
             when(argAddrArg) {
-                is AddressOf -> {
-                    if(argAddrArg.identifier.targetVarDecl(program)?.datatype != DataType.UBYTE)
+                is PtAddressOf -> {
+                    if(argAddrArg.identifier.type != DataType.UBYTE)
                         throw AssemblyError("callfar done with 'arg' pointer to variable that's not UBYTE")
                     asmgen.out("""
                         lda  ${asmgen.asmVariableName(argAddrArg.identifier)}
@@ -163,7 +159,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         .byte  ${bank.toHex()}
                         sta  ${asmgen.asmVariableName(argAddrArg.identifier)}""")
                 }
-                is NumericLiteral -> {
+                is PtNumber -> {
                     asmgen.out("""
                         lda  ${argAddrArg.number.toHex()}
                         jsr  cx16.jsrfar
@@ -176,12 +172,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcCallRom(fcall: IFunctionCall) {
+    private fun funcCallRom(fcall: PtBuiltinFunctionCall) {
         if(asmgen.options.compTarget.name != "cx16")
             throw AssemblyError("callrom only works on cx16 target at this time")
 
-        val bank = fcall.args[0].constValue(program)?.number?.toInt()
-        val address = fcall.args[1].constValue(program)?.number?.toInt()
+        val bank = fcall.args[0].asConstInteger()
+        val address = fcall.args[1].asConstInteger()
         if(bank==null || address==null)
             throw AssemblyError("callrom requires constant arguments")
 
@@ -191,7 +187,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             throw AssemblyError("callrom bank must be <32")
 
         val argAddrArg = fcall.args[2]
-        if(argAddrArg.constValue(program)?.number == 0.0) {
+        if(argAddrArg.asConstInteger() == 0) {
             asmgen.out("""
                 lda  $01
                 pha
@@ -202,8 +198,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                 sta  $01""")
         } else {
             when(argAddrArg) {
-                is AddressOf -> {
-                    if(argAddrArg.identifier.targetVarDecl(program)?.datatype != DataType.UBYTE)
+                is PtAddressOf -> {
+                    if(argAddrArg.identifier.type != DataType.UBYTE)
                         throw AssemblyError("callrom done with 'arg' pointer to variable that's not UBYTE")
                     asmgen.out("""
                         lda  $01
@@ -216,7 +212,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         pla
                         sta  $01""")
                 }
-                is NumericLiteral -> {
+                is PtNumber -> {
                     asmgen.out("""
                         lda  $01
                         pha
@@ -233,46 +229,44 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcCmp(fcall: IFunctionCall) {
+    private fun funcCmp(fcall: PtBuiltinFunctionCall) {
         val arg1 = fcall.args[0]
         val arg2 = fcall.args[1]
-        val dt1 = arg1.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-        val dt2 = arg2.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-        if(dt1 in ByteDatatypes) {
-            if(dt2 in ByteDatatypes) {
+        if(arg1.type in ByteDatatypes) {
+            if(arg2.type in ByteDatatypes) {
                 when (arg2) {
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                         asmgen.out("  cmp  ${asmgen.asmVariableName(arg2)}")
                     }
-                    is NumericLiteral -> {
+                    is PtNumber -> {
                         asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                         asmgen.out("  cmp  #${arg2.number.toInt()}")
                     }
-                    is DirectMemoryRead -> {
-                        if(arg2.addressExpression is NumericLiteral) {
+                    is PtMemoryByte -> {
+                        if(arg2.address is PtNumber) {
                             asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
-                            asmgen.out("  cmp  ${arg2.addressExpression.constValue(program)!!.number.toHex()}")
+                            asmgen.out("  cmp  ${arg2.address.asConstInteger()!!.toHex()}")
                         } else {
-                            if(arg1.isSimple) {
-                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, (fcall as Node).definingSubroutine)
+                            if(arg1.isSimple()) {
+                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
                                 asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                                 asmgen.out("  cmp  P8ZP_SCRATCH_B1")
                             } else {
                                 asmgen.pushCpuStack(DataType.UBYTE, arg1)
-                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, (fcall as Node).definingSubroutine)
+                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
                                 asmgen.out("  pla |  cmp  P8ZP_SCRATCH_B1")
                             }
                         }
                     }
                     else -> {
-                        if(arg1.isSimple) {
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, (fcall as Node).definingSubroutine)
+                        if(arg1.isSimple()) {
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
                             asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                             asmgen.out("  cmp  P8ZP_SCRATCH_B1")
                         } else {
                             asmgen.pushCpuStack(DataType.UBYTE, arg1)
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, (fcall as Node).definingSubroutine)
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
                             asmgen.out("  pla |  cmp  P8ZP_SCRATCH_B1")
                         }
                     }
@@ -280,10 +274,10 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             } else
                 throw AssemblyError("args for cmp() should have same dt")
         } else {
-            // dt1 is a word
-            if(dt2 in WordDatatypes) {
+            // arg1 is a word
+            if(arg2.type in WordDatatypes) {
                 when (arg2) {
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
                         asmgen.out("""
                             cpy  ${asmgen.asmVariableName(arg2)}+1
@@ -291,7 +285,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                             cmp  ${asmgen.asmVariableName(arg2)}
 +""")
                     }
-                    is NumericLiteral -> {
+                    is PtNumber -> {
                         asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
                         asmgen.out("""
                             cpy  #>${arg2.number.toInt()}
@@ -300,8 +294,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
 +""")
                     }
                     else -> {
-                        if(arg1.isSimple) {
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, (fcall as Node).definingSubroutine)
+                        if(arg1.isSimple()) {
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, fcall.definingISub())
                             asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
                             asmgen.out("""
                                 cpy  P8ZP_SCRATCH_W1+1
@@ -310,7 +304,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
     +""")
                         } else {
                             asmgen.pushCpuStack(DataType.UWORD, arg1)
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, (fcall as Node).definingSubroutine)
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, fcall.definingISub())
                             asmgen.restoreRegisterStack(CpuRegister.Y, false)
                             asmgen.restoreRegisterStack(CpuRegister.A, false)
                             asmgen.out("""
@@ -326,14 +320,16 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcMemory(fcall: IFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
-        if(discardResult || fcall !is BuiltinFunctionCall)
+    private fun funcMemory(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+        if(discardResult)
             throw AssemblyError("should not discard result of memory allocation at $fcall")
-        val name = (fcall.args[0] as StringLiteral).value
+        val name = (fcall.args[0] as PtString).value
         require(name.all { it.isLetterOrDigit() || it=='_' }) {"memory name should be a valid symbol name ${fcall.position}"}
-        val slabname = IdentifierReference(listOf("prog8_slabs", "prog8_memoryslab_$name"), fcall.position)
-        slabname.linkParents(fcall)
-        val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UWORD, expression = AddressOf(slabname, fcall.position))
+        val slabname = PtIdentifier("prog8_slabs.prog8_memoryslab_$name", DataType.UWORD, fcall.position)
+        val addressOf = PtAddressOf(fcall.position)
+        addressOf.add(slabname)
+        addressOf.parent = fcall
+        val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UWORD, expression = addressOf)
         val target =
             if(resultToStack)
                 AsmAssignTarget(TargetStorageKind.STACK,  asmgen, DataType.UWORD, null)
@@ -343,8 +339,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         asmgen.translateNormalAssignment(assign)
     }
 
-    private fun funcSqrt16(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        translateArguments(fcall.args, func, scope)
+    private fun funcSqrt16(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+        translateArguments(fcall, scope)
         if(resultToStack)
             asmgen.out("  jsr  prog8_lib.func_sqrt16_stack")
         else {
@@ -353,13 +349,18 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcReverse(fcall: IFunctionCall) {
+    private fun funcReverse(fcall: PtBuiltinFunctionCall) {
         val variable = fcall.args.single()
-        if (variable is IdentifierReference) {
-            val decl = variable.targetVarDecl(program)!!
+        if (variable is PtIdentifier) {
+            val symbol = asmgen.symbolTable.lookup(variable.name)
+            val decl = symbol!!.astNode as IPtVariable
+            val numElements = when(decl) {
+                is PtConstant -> throw AssemblyError("cannot reverse a constant")
+                is PtMemMapped -> decl.arraySize
+                is PtVariable -> decl.arraySize
+            }
             val varName = asmgen.asmVariableName(variable)
-            val numElements = decl.arraysize!!.constIndex()
-            when (decl.datatype) {
+            when (decl.type) {
                 DataType.ARRAY_UB, DataType.ARRAY_B -> {
                     asmgen.out("""
                         lda  #<$varName
@@ -392,13 +393,18 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcSort(fcall: IFunctionCall) {
+    private fun funcSort(fcall: PtBuiltinFunctionCall) {
         val variable = fcall.args.single()
-        if (variable is IdentifierReference) {
-            val decl = variable.targetVarDecl(program)!!
+        if (variable is PtIdentifier) {
+            val symbol = asmgen.symbolTable.lookup(variable.name)
+            val decl = symbol!!.astNode as IPtVariable
             val varName = asmgen.asmVariableName(variable)
-            val numElements = decl.arraysize!!.constIndex()
-            when (decl.datatype) {
+            val numElements = when(decl) {
+                is PtConstant -> throw AssemblyError("cannot sort a constant")
+                is PtMemMapped -> decl.arraySize
+                is PtVariable -> decl.arraySize
+            }
+            when (decl.type) {
                 DataType.ARRAY_UB, DataType.ARRAY_B -> {
                     asmgen.out("""
                         lda  #<$varName
@@ -406,7 +412,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         sta  P8ZP_SCRATCH_W1
                         sty  P8ZP_SCRATCH_W1+1
                         lda  #$numElements""")
-                    asmgen.out(if (decl.datatype == DataType.ARRAY_UB) "  jsr  prog8_lib.func_sort_ub" else "  jsr  prog8_lib.func_sort_b")
+                    asmgen.out(if (decl.type == DataType.ARRAY_UB) "  jsr  prog8_lib.func_sort_ub" else "  jsr  prog8_lib.func_sort_b")
                 }
                 DataType.ARRAY_UW, DataType.ARRAY_W -> {
                     asmgen.out("""
@@ -415,7 +421,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         sta  P8ZP_SCRATCH_W1
                         sty  P8ZP_SCRATCH_W1+1
                         lda  #$numElements""")
-                    asmgen.out(if (decl.datatype == DataType.ARRAY_UW) "  jsr  prog8_lib.func_sort_uw" else "  jsr  prog8_lib.func_sort_w")
+                    asmgen.out(if (decl.type == DataType.ARRAY_UW) "  jsr  prog8_lib.func_sort_uw" else "  jsr  prog8_lib.func_sort_w")
                 }
                 DataType.ARRAY_F -> throw AssemblyError("sorting of floating point array is not supported")
                 else -> throw AssemblyError("weird type")
@@ -424,26 +430,25 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             throw AssemblyError("weird type")
     }
 
-    private fun funcRor2(fcall: IFunctionCall) {
+    private fun funcRor2(fcall: PtBuiltinFunctionCall) {
         val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.getOr(DataType.UNDEFINED)) {
+        when (what.type) {
             DataType.UBYTE -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror2", 'b')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "ror2", 'b')
                         asmgen.out("  jsr  prog8_lib.ror2_array_ub")
                     }
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteral) {
-                            val number = (what.addressExpression as NumericLiteral).number
+                    is PtMemoryByte -> {
+                        if (what.address is PtNumber) {
+                            val number = (what.address as PtNumber).number
                             asmgen.out("  lda  ${number.toHex()} |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  ${number.toHex()}")
                         } else {
-                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
+                            asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                             asmgen.out("  jsr  prog8_lib.ror2_mem_ub")
                         }
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lda  $variable |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  $variable")
                     }
@@ -452,11 +457,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             }
             DataType.UWORD -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror2", 'w')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "ror2", 'w')
                         asmgen.out("  jsr  prog8_lib.ror2_array_uw")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lsr  $variable+1 |  ror  $variable |  bcc  + |  lda  $variable+1 |  ora  #\$80 |  sta  $variable+1 |+  ")
                     }
@@ -467,26 +472,25 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcRor(fcall: IFunctionCall) {
+    private fun funcRor(fcall: PtBuiltinFunctionCall) {
         val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.getOr(DataType.UNDEFINED)) {
+        when (what.type) {
             DataType.UBYTE -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror", 'b')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "ror", 'b')
                         asmgen.out("  jsr  prog8_lib.ror_array_ub")
                     }
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteral) {
-                            val number = (what.addressExpression as NumericLiteral).number
+                    is PtMemoryByte -> {
+                        if (what.address is PtNumber) {
+                            val number = (what.address as PtNumber).number
                             asmgen.out("  ror  ${number.toHex()}")
                         } else {
-                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.addressExpression)
+                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.address)
                             if(ptrAndIndex!=null) {
-                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
-                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
                                 asmgen.restoreRegisterLocal(CpuRegister.X)
                                 asmgen.out("""
@@ -495,7 +499,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
 +                                   ror  ${'$'}ffff,x           ; modified""")
                                 asmgen.restoreRegisterLocal(CpuRegister.X)
                             } else {
-                                asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
+                                asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                                 asmgen.out("""
                                     sta  (+) + 1
                                     sty  (+) + 2
@@ -503,7 +507,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                             }
                         }
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  ror  $variable")
                     }
@@ -512,11 +516,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             }
             DataType.UWORD -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "ror", 'w')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "ror", 'w')
                         asmgen.out("  jsr  prog8_lib.ror_array_uw")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  ror  $variable+1 |  ror  $variable")
                     }
@@ -527,26 +531,25 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcRol2(fcall: IFunctionCall) {
+    private fun funcRol2(fcall: PtBuiltinFunctionCall) {
         val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.getOr(DataType.UNDEFINED)) {
+        when (what.type) {
             DataType.UBYTE -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol2", 'b')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "rol2", 'b')
                         asmgen.out("  jsr  prog8_lib.rol2_array_ub")
                     }
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteral) {
-                            val number = (what.addressExpression as NumericLiteral).number
+                    is PtMemoryByte -> {
+                        if (what.address is PtNumber) {
+                            val number = (what.address as PtNumber).number
                             asmgen.out("  lda  ${number.toHex()} |  cmp  #\$80 |  rol  a |  sta  ${number.toHex()}")
                         } else {
-                            asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
+                            asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                             asmgen.out("  jsr  prog8_lib.rol2_mem_ub")
                         }
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  lda  $variable |  cmp  #\$80 |  rol  a |  sta  $variable")
                     }
@@ -555,11 +558,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             }
             DataType.UWORD -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol2", 'w')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "rol2", 'w')
                         asmgen.out("  jsr  prog8_lib.rol2_array_uw")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  asl  $variable |  rol  $variable+1 |  bcc  + |  inc  $variable |+  ")
                     }
@@ -570,26 +573,25 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcRol(fcall: IFunctionCall) {
+    private fun funcRol(fcall: PtBuiltinFunctionCall) {
         val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.getOr(DataType.UNDEFINED)) {
+        when (what.type) {
             DataType.UBYTE -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol", 'b')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "rol", 'b')
                         asmgen.out("  jsr  prog8_lib.rol_array_ub")
                     }
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteral) {
-                            val number = (what.addressExpression as NumericLiteral).number
+                    is PtMemoryByte -> {
+                        if (what.address is PtNumber) {
+                            val number = (what.address as PtNumber).number
                             asmgen.out("  rol  ${number.toHex()}")
                         } else {
-                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.addressExpression)
+                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.address)
                             if(ptrAndIndex!=null) {
-                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
-                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
                                 asmgen.restoreRegisterLocal(CpuRegister.X)
                                 asmgen.out("""
@@ -598,7 +600,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
 +                                   rol  ${'$'}ffff,x           ; modified""")
                                 asmgen.restoreRegisterLocal(CpuRegister.X)
                             } else {
-                                asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
+                                asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                                 asmgen.out("""
                                     sta  (+) + 1
                                     sty  (+) + 2
@@ -606,7 +608,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                             }
                         }
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  rol  $variable")
                     }
@@ -615,11 +617,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             }
             DataType.UWORD -> {
                 when (what) {
-                    is ArrayIndexedExpression -> {
-                        translateRolRorArrayArgs(what.arrayvar, what.indexer, "rol", 'w')
+                    is PtArrayIndexer -> {
+                        translateRolRorArrayArgs(what.variable, what, "rol", 'w')
                         asmgen.out("  jsr  prog8_lib.rol_array_uw")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val variable = asmgen.asmVariableName(what)
                         asmgen.out("  rol  $variable |  rol  $variable+1")
                     }
@@ -630,22 +632,25 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateRolRorArrayArgs(arrayvar: IdentifierReference, indexer: ArrayIndex, operation: String, dt: Char) {
-        if(arrayvar.targetVarDecl(program)!!.datatype==DataType.UWORD) {
+    private fun translateRolRorArrayArgs(arrayvar: PtIdentifier, indexer: PtArrayIndexer, operation: String, dt: Char) {
+        if(arrayvar.type==DataType.UWORD) {
             if(dt!='b')
                 throw AssemblyError("non-array var indexing requires bytes dt")
             asmgen.assignExpressionToVariable(arrayvar, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
         } else {
-            asmgen.assignExpressionToVariable(AddressOf(arrayvar, arrayvar.position), "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
+            val addressOf = PtAddressOf(arrayvar.position)
+            addressOf.add(arrayvar)
+            addressOf.parent = arrayvar.parent.parent
+            asmgen.assignExpressionToVariable(addressOf, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
         }
-        asmgen.assignExpressionToVariable(indexer.indexExpr, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
+        asmgen.assignExpressionToVariable(indexer.index, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
     }
 
-    private fun funcSgn(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        translateArguments(fcall.args, func, scope)
-        val dt = fcall.args.single().inferType(program)
+    private fun funcSgn(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+        translateArguments(fcall, scope)
+        val dt = fcall.args.single().type
         if(resultToStack) {
-            when (dt.getOr(DataType.UNDEFINED)) {
+            when (dt) {
                 DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_stack")
                 DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_stack")
                 DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_stack")
@@ -654,7 +659,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                 else -> throw AssemblyError("weird type $dt")
             }
         } else {
-            when (dt.getOr(DataType.UNDEFINED)) {
+            when (dt) {
                 DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_into_A")
                 DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_into_A")
                 DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_into_A")
@@ -666,30 +671,30 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcAnyAll(fcall: IFunctionCall, function: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
+    private fun funcAnyAll(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         outputAddressAndLenghtOfArray(fcall.args[0])
-        val dt = fcall.args.single().inferType(program)
+        val dt = fcall.args.single().type
         if(resultToStack) {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${function.name}_b_stack")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${function.name}_w_stack")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${function.name}_f_stack")
+            when (dt) {
+                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_stack")
+                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_stack")
+                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_stack")
                 else -> throw AssemblyError("weird type $dt")
             }
         } else {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${function.name}_b_into_A |  ldy  #0")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${function.name}_w_into_A |  ldy  #0")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${function.name}_f_into_A |  ldy  #0")
+            when (dt) {
+                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A |  ldy  #0")
+                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_into_A |  ldy  #0")
+                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_into_A |  ldy  #0")
                 else -> throw AssemblyError("weird type $dt")
             }
             assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, asmgen), CpuRegister.A)
         }
     }
 
-    private fun funcAbs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        translateArguments(fcall.args, func, scope)
-        val dt = fcall.args.single().inferType(program).getOr(DataType.UNDEFINED)
+    private fun funcAbs(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+        translateArguments(fcall, scope)
+        val dt = fcall.args.single().type
         if(resultToStack) {
             when (dt) {
                 DataType.UBYTE -> asmgen.out("  ldy  #0")
@@ -710,19 +715,19 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcPokeW(fcall: IFunctionCall) {
+    private fun funcPokeW(fcall: PtBuiltinFunctionCall) {
         when(val addrExpr = fcall.args[0]) {
-            is NumericLiteral -> {
+            is PtNumber -> {
                 asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY)
                 val addr = addrExpr.number.toHex()
                 asmgen.out("  sta  $addr |  sty  ${addr}+1")
                 return
             }
-            is IdentifierReference -> {
+            is PtIdentifier -> {
                 val varname = asmgen.asmVariableName(addrExpr)
                 if(asmgen.isZpVar(addrExpr)) {
                     // pointervar is already in the zero page, no need to copy
-                    asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                     asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
                     if (asmgen.isTargetCpu(CpuType.CPU65c02)) {
                         asmgen.out("""
@@ -742,14 +747,14 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                     return
                 }
             }
-            is BinaryExpression -> {
-                if(addrExpr.operator=="+" && addrExpr.left is IdentifierReference && addrExpr.right is NumericLiteral) {
-                    val varname = asmgen.asmVariableName(addrExpr.left as IdentifierReference)
-                    if(asmgen.isZpVar(addrExpr.left as IdentifierReference)) {
+            is PtBinaryExpression -> {
+                if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier && addrExpr.right is PtNumber) {
+                    val varname = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
+                    if(asmgen.isZpVar(addrExpr.left as PtIdentifier)) {
                         // pointervar is already in the zero page, no need to copy
-                        asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
+                        asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                         asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
-                        val index = (addrExpr.right as NumericLiteral).number.toHex()
+                        val index = (addrExpr.right as PtNumber).number.toHex()
                         asmgen.out("""
                             ldy  #$index
                             sta  ($varname),y
@@ -769,13 +774,13 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         asmgen.out("  jsr  prog8_lib.func_pokew")
     }
 
-    private fun funcPeekW(fcall: IFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcPeekW(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
         when(val addrExpr = fcall.args[0]) {
-            is NumericLiteral -> {
+            is PtNumber -> {
                 val addr = addrExpr.number.toHex()
                 asmgen.out("  lda  $addr |  ldy  ${addr}+1")
             }
-            is IdentifierReference -> {
+            is PtIdentifier -> {
                 val varname = asmgen.asmVariableName(addrExpr)
                 if(asmgen.isZpVar(addrExpr)) {
                     // pointervar is already in the zero page, no need to copy
@@ -800,12 +805,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                     asmgen.out("  jsr  prog8_lib.func_peekw")
                 }
             }
-            is BinaryExpression -> {
-                if(addrExpr.operator=="+" && addrExpr.left is IdentifierReference && addrExpr.right is NumericLiteral) {
-                    val varname = asmgen.asmVariableName(addrExpr.left as IdentifierReference)
-                    if(asmgen.isZpVar(addrExpr.left as IdentifierReference)) {
+            is PtBinaryExpression -> {
+                if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier && addrExpr.right is PtNumber) {
+                    val varname = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
+                    if(asmgen.isZpVar(addrExpr.left as PtIdentifier)) {
                         // pointervar is already in the zero page, no need to copy
-                        val index = (addrExpr.right as NumericLiteral).number.toHex()
+                        val index = (addrExpr.right as PtNumber).number.toHex()
                         asmgen.out("""
                             ldy  #$index
                             lda  ($varname),y
@@ -845,7 +850,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcMkword(fcall: IFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMkword(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
         if(resultToStack) {
             asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
             asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
@@ -854,12 +859,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             val reg = resultRegister ?: RegisterOrPair.AY
             var needAsave = asmgen.needAsaveForExpr(fcall.args[0])
             if(!needAsave) {
-                val mr0 = fcall.args[0] as? DirectMemoryRead
-                val mr1 = fcall.args[1] as? DirectMemoryRead
+                val mr0 = fcall.args[0] as? PtMemoryByte
+                val mr1 = fcall.args[1] as? PtMemoryByte
                 if (mr0 != null)
-                    needAsave =  mr0.addressExpression !is NumericLiteral
+                    needAsave =  mr0.address !is PtNumber
                 if (mr1 != null)
-                    needAsave = needAsave or (mr1.addressExpression !is NumericLiteral)
+                    needAsave = needAsave or (mr1.address !is PtNumber)
             }
             when(reg) {
                 RegisterOrPair.AX -> {
@@ -898,13 +903,13 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcMsb(fcall: IFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMsb(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
         val arg = fcall.args.single()
-        if (!arg.inferType(program).isWords)
+        if (arg.type !in WordDatatypes)
             throw AssemblyError("msb required word argument")
-        if (arg is NumericLiteral)
+        if (arg is PtNumber)
             throw AssemblyError("msb(const) should have been const-folded away")
-        if (arg is IdentifierReference) {
+        if (arg is PtIdentifier) {
             val sourceName = asmgen.asmVariableName(arg)
             if(resultToStack) {
                 asmgen.out("  lda  $sourceName+1 |  sta  P8ESTACK_LO,x |  dex")
@@ -952,14 +957,14 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun funcLsb(fcall: IFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcLsb(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
         val arg = fcall.args.single()
-        if (!arg.inferType(program).isWords)
+        if (arg.type !in WordDatatypes)
             throw AssemblyError("lsb required word argument")
-        if (arg is NumericLiteral)
+        if (arg is PtNumber)
             throw AssemblyError("lsb(const) should have been const-folded away")
 
-        if (arg is IdentifierReference) {
+        if (arg is PtIdentifier) {
             val sourceName = asmgen.asmVariableName(arg)
             if(resultToStack) {
                 asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x |  dex")
@@ -1013,35 +1018,39 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
         }
     }
 
-    private fun outputAddressAndLenghtOfArray(arg: Expression) {
+    private fun outputAddressAndLenghtOfArray(arg: PtExpression) {
         // address in P8ZP_SCRATCH_W1,  number of elements in A
-        arg as IdentifierReference
-        val arrayVar = arg.targetVarDecl(program)!!
-        if(!arrayVar.isArray)
-            throw AssemblyError("length of non-array requested")
-        val size = arrayVar.arraysize!!.constIndex()!!
+        arg as PtIdentifier
+        val symbol = asmgen.symbolTable.lookup(arg.name)
+        val arrayVar = symbol!!.astNode as IPtVariable
+        val numElements = when(arrayVar) {
+            is PtConstant -> null
+            is PtMemMapped -> arrayVar.arraySize
+            is PtVariable -> arrayVar.arraySize
+        } ?: throw AssemblyError("length of non-array requested")
         val identifierName = asmgen.asmVariableName(arg)
         asmgen.out("""
                     lda  #<$identifierName
                     ldy  #>$identifierName
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1
-                    lda  #$size
+                    lda  #$numElements
                     """)
     }
 
-    private fun translateArguments(args: MutableList<Expression>, signature: FSignature, scope: Subroutine?) {
-        val callConv = signature.callConvention(args.map {
-            it.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-        })
+    private fun translateArguments(call: PtBuiltinFunctionCall, scope: IPtSubroutine?) {
+        val signature = BuiltinFunctions.getValue(call.name)
+        val callConv = signature.callConvention(call.args.map { it.type})
 
-        fun getSourceForFloat(value: Expression): AsmAssignSource {
+        fun getSourceForFloat(value: PtExpression): AsmAssignSource {
             return when (value) {
-                is IdentifierReference -> {
-                    val addr = AddressOf(value, value.position)
+                is PtIdentifier -> {
+                    val addr = PtAddressOf(value.position)
+                    addr.add(value)
+                    addr.parent = call
                     AsmAssignSource.fromAstSource(addr, program, asmgen)
                 }
-                is NumericLiteral -> {
+                is PtNumber -> {
                     throw AssemblyError("float literals should have been converted into autovar")
                 }
                 else -> {
@@ -1049,27 +1058,30 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         throw AssemblyError("cannot use float arguments outside of a subroutine scope")
 
                     asmgen.subroutineExtra(scope).usedFloatEvalResultVar2 = true
-                    val variable = IdentifierReference(listOf(subroutineFloatEvalResultVar2), value.position)
-                    val addr = AddressOf(variable, value.position)
-                    addr.linkParents(value)
+                    val variable = PtIdentifier(subroutineFloatEvalResultVar2, DataType.FLOAT, value.position)
+                    val addr = PtAddressOf(value.position)
+                    addr.add(variable)
+                    addr.parent = call
                     asmgen.assignExpressionToVariable(value, asmgen.asmVariableName(variable), DataType.FLOAT, scope)
                     AsmAssignSource.fromAstSource(addr, program, asmgen)
                 }
             }
         }
 
-        args.zip(callConv.params).zip(signature.parameters).forEach {
+        call.args.zip(callConv.params).zip(signature.parameters).forEach {
             val paramName = it.second.name
             val conv = it.first.second
             val value = it.first.first
             when {
                 conv.variable -> {
-                    val varname = "prog8_lib.func_${signature.name}._arg_${paramName}"
+                    val varname = "prog8_lib.func_${call.name}._arg_${paramName}"
                     val src = when (conv.dt) {
                         DataType.FLOAT -> getSourceForFloat(value)
                         in PassByReferenceDatatypes -> {
                             // put the address of the argument in AY
-                            val addr = AddressOf(value as IdentifierReference, value.position)
+                            val addr = PtAddressOf(value.position)
+                            addr.add(value)
+                            addr.parent = call
                             AsmAssignSource.fromAstSource(addr, program, asmgen)
                         }
                         else -> {
@@ -1085,7 +1097,9 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                         DataType.FLOAT -> getSourceForFloat(value)
                         in PassByReferenceDatatypes -> {
                             // put the address of the argument in AY
-                            val addr = AddressOf(value as IdentifierReference, value.position)
+                            val addr = PtAddressOf(value.position)
+                            addr.add(value)
+                            addr.parent = call
                             AsmAssignSource.fromAstSource(addr, program, asmgen)
                         }
                         else -> {

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

@@ -1,16 +1,15 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.Program
-import prog8.ast.expressions.*
+import prog8.code.ast.*
 import prog8.code.core.*
 import kotlin.math.absoluteValue
 
-internal class ExpressionsAsmGen(private val program: Program,
-                                 private val asmgen: AsmGen,
+internal class ExpressionsAsmGen(private val program: PtProgram,
+                                 private val asmgen: AsmGen6502Internal,
                                  private val allocator: VariableAllocator) {
 
     @Deprecated("avoid calling this as it generates slow evalstack based code")
-    internal fun translateExpression(expression:Expression) {
+    internal fun translateExpression(expression: PtExpression) {
         if (this.asmgen.options.slowCodegenWarnings) {
             asmgen.errors.warn("slow stack evaluation used for expression $expression", expression.position)
         }
@@ -21,41 +20,42 @@ internal class ExpressionsAsmGen(private val program: Program,
     // the rest of the methods are all PRIVATE
 
 
-    private fun translateExpressionInternal(expression: Expression) {
+    private fun translateExpressionInternal(expression: PtExpression) {
 
         when(expression) {
-            is PrefixExpression -> translateExpression(expression)
-            is BinaryExpression -> translateExpression(expression)
-            is ArrayIndexedExpression -> translateExpression(expression)
-            is TypecastExpression -> translateExpression(expression)
-            is AddressOf -> translateExpression(expression)
-            is DirectMemoryRead -> asmgen.translateDirectMemReadExpressionToRegAorStack(expression, true)
-            is NumericLiteral -> translateExpression(expression)
-            is IdentifierReference -> translateExpression(expression)
-            is FunctionCallExpression -> translateFunctionCallResultOntoStack(expression)
-            is BuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
-            is ContainmentCheck -> throw AssemblyError("containment check as complex expression value is not supported")
-            is ArrayLiteral, is StringLiteral -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
-            is RangeExpression -> throw AssemblyError("range expression should have been changed into array values")
-            is CharLiteral -> throw AssemblyError("charliteral should have been replaced by ubyte using certain encoding")
+            is PtPrefix -> translateExpression(expression)
+            is PtBinaryExpression -> translateExpression(expression)
+            is PtArrayIndexer -> translateExpression(expression)
+            is PtTypeCast -> translateExpression(expression)
+            is PtAddressOf -> translateExpression(expression)
+            is PtMemoryByte -> asmgen.translateDirectMemReadExpressionToRegAorStack(expression, true)
+            is PtNumber -> translateExpression(expression)
+            is PtIdentifier -> translateExpression(expression)
+            is PtFunctionCall -> translateFunctionCallResultOntoStack(expression)
+            is PtBuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
+            is PtContainmentCheck -> throw AssemblyError("containment check as complex expression value is not supported")
+            is PtArray, is PtString -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
+            is PtRange -> throw AssemblyError("range expression should have been changed into array values")
+            is PtMachineRegister -> throw AssemblyError("machine register ast node should not occur in 6502 codegen it is for IR code")
             else -> TODO("missing expression asmgen for $expression")
         }
     }
 
-    private fun translateFunctionCallResultOntoStack(call: FunctionCallExpression) {
+    private fun translateFunctionCallResultOntoStack(call: PtFunctionCall) {
         // only for use in nested expression evaluation
 
-        val sub = call.target.targetSubroutine(program)!!
+        val symbol = asmgen.symbolTable.lookup(call.name)
+        val sub = symbol!!.astNode as IPtSubroutine
         asmgen.saveXbeforeCall(call)
-        asmgen.translateFunctionCall(call, true)
+        asmgen.translateFunctionCall(call)
         if(sub.regXasResult()) {
             // store the return value in X somewhere that we can access again below
             asmgen.out("  stx  P8ZP_SCRATCH_REG")
         }
         asmgen.restoreXafterCall(call)
 
-        val returns = sub.returntypes.zip(sub.asmReturnvaluesRegisters)
-        for ((_, reg) in returns) {
+        val returns: List<Pair<RegisterOrStatusflag, DataType>> = sub.returnsWhatWhere()
+        for ((reg, _) in returns) {
             // result value is in cpu or status registers, put it on the stack instead (as we're evaluating an expression tree)
             if (reg.registerOrPair != null) {
                 when (reg.registerOrPair!!) {
@@ -133,9 +133,9 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateExpression(typecast: TypecastExpression) {
-        translateExpressionInternal(typecast.expression)
-        when(typecast.expression.inferType(program).getOr(DataType.UNDEFINED)) {
+    private fun translateExpression(typecast: PtTypeCast) {
+        translateExpressionInternal(typecast.value)
+        when(typecast.value.type) {
             DataType.UBYTE, DataType.BOOL -> {
                 when(typecast.type) {
                     DataType.UBYTE, DataType.BYTE -> {}
@@ -197,12 +197,12 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateExpression(expr: AddressOf) {
+    private fun translateExpression(expr: PtAddressOf) {
         val name = asmgen.asmVariableName(expr.identifier)
         asmgen.out("  lda  #<$name |  sta  P8ESTACK_LO,x |  lda  #>$name  |  sta  P8ESTACK_HI,x  | dex")
     }
 
-    private fun translateExpression(expr: NumericLiteral) {
+    private fun translateExpression(expr: PtNumber) {
         when(expr.type) {
             DataType.UBYTE, DataType.BYTE -> asmgen.out(" lda  #${expr.number.toHex()}  | sta  P8ESTACK_LO,x  | dex")
             DataType.UWORD, DataType.WORD -> asmgen.out("""
@@ -220,9 +220,9 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateExpression(expr: IdentifierReference) {
+    private fun translateExpression(expr: PtIdentifier) {
         val varname = asmgen.asmVariableName(expr)
-        when(expr.inferType(program).getOr(DataType.UNDEFINED)) {
+        when(expr.type) {
             DataType.UBYTE, DataType.BYTE -> {
                 asmgen.out("  lda  $varname  |  sta  P8ESTACK_LO,x  |  dex")
             }
@@ -239,22 +239,17 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateExpression(expr: BinaryExpression) {
+    private fun translateExpression(expr: PtBinaryExpression) {
         // Uses evalstack to evaluate the given expression.
         // TODO we're slowly reducing the number of places where this is called and instead replace that by more efficient assignment-form code (using temp var or register for instance).
-        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.getOrElse { throw AssemblyError("unknown dt") }
-        val rightDt = rightIDt.getOrElse { throw AssemblyError("unknown dt") }
+        val leftDt = expr.left.type
+        val rightDt = expr.right.type
         // see if we can apply some optimized routines
         when(expr.operator) {
             "+" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVal = expr.left.constValue(program)?.number?.toInt()
-                    val rightVal = expr.right.constValue(program)?.number?.toInt()
+                    val leftVal = expr.left.asConstInteger()
+                    val rightVal = expr.right.asConstInteger()
                     if (leftVal!=null && leftVal in -4..4) {
                         translateExpressionInternal(expr.right)
                         if(rightDt in ByteDatatypes) {
@@ -318,7 +313,7 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             "-" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = expr.right.constValue(program)?.number?.toInt()
+                    val rightVal = expr.right.asConstInteger()
                     if (rightVal!=null && rightVal in -4..4)
                     {
                         translateExpressionInternal(expr.left)
@@ -352,7 +347,7 @@ internal class ExpressionsAsmGen(private val program: Program,
                 }
             }
             ">>" -> {
-                val amount = expr.right.constValue(program)?.number?.toInt()
+                val amount = expr.right.asConstInteger()
                 if(amount!=null) {
                     translateExpressionInternal(expr.left)
                     when (leftDt) {
@@ -423,7 +418,7 @@ internal class ExpressionsAsmGen(private val program: Program,
                 }
             }
             "<<" -> {
-                val amount = expr.right.constValue(program)?.number?.toInt()
+                val amount = expr.right.asConstInteger()
                 if(amount!=null) {
                     translateExpressionInternal(expr.left)
                     if (leftDt in ByteDatatypes) {
@@ -450,13 +445,13 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             "*" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVar = expr.left as? IdentifierReference
-                    val rightVar = expr.right as? IdentifierReference
+                    val leftVar = expr.left as? PtIdentifier
+                    val rightVar = expr.right as? PtIdentifier
                     if(leftVar!=null && rightVar!=null && leftVar==rightVar)
                         return translateSquared(leftVar, leftDt)
                 }
 
-                val value = expr.right.constValue(program)
+                val value = expr.right as? PtNumber
                 if(value!=null) {
                     if(rightDt in IntegerDatatypes) {
                         val amount = value.number.toInt()
@@ -516,7 +511,7 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             "/" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = expr.right.constValue(program)?.number?.toInt()
+                    val rightVal = expr.right.asConstInteger()
                     if(rightVal!=null && rightVal==2) {
                         translateExpressionInternal(expr.left)
                         when (leftDt) {
@@ -557,8 +552,8 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             in ComparisonOperators -> {
                 if(leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
-                    val rightVal = expr.right.constValue(program)?.number
-                    if(rightVal==0.0)
+                    val rightVal = expr.right.asConstInteger()
+                    if(rightVal==0)
                         return translateComparisonWithZero(expr.left, leftDt, expr.operator)
                 }
             }
@@ -584,8 +579,8 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateComparisonWithZero(expr: Expression, dt: DataType, operator: String) {
-        if(expr.isSimple) {
+    private fun translateComparisonWithZero(expr: PtExpression, dt: DataType, operator: String) {
+        if(expr.isSimple()) {
             if(operator=="!=") {
                 when (dt) {
                     in ByteDatatypes -> {
@@ -641,7 +636,7 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             "<" -> {
                 if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(NumericLiteral.fromBoolean(false, expr.position))
+                    return translateExpressionInternal(PtNumber.fromBoolean(false, expr.position))
                 when(dt) {
                     DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lesszero_b")
                     DataType.WORD -> asmgen.out("  jsr  prog8_lib.lesszero_w")
@@ -671,7 +666,7 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             ">=" -> {
                 if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(NumericLiteral.fromBoolean(true, expr.position))
+                    return translateExpressionInternal(PtNumber.fromBoolean(true, expr.position))
                 when(dt) {
                     DataType.BYTE -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sb")
                     DataType.WORD -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sw")
@@ -683,7 +678,7 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateSquared(variable: IdentifierReference, dt: DataType) {
+    private fun translateSquared(variable: PtIdentifier, dt: DataType) {
         val asmVar = asmgen.asmVariableName(variable)
         when(dt) {
             DataType.BYTE, DataType.UBYTE -> {
@@ -699,14 +694,12 @@ internal class ExpressionsAsmGen(private val program: Program,
         asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
     }
 
-    private fun translateExpression(expr: PrefixExpression) {
-        translateExpressionInternal(expr.expression)
-        val itype = expr.inferType(program)
-        val type = itype.getOrElse { throw AssemblyError("unknown dt") }
+    private fun translateExpression(expr: PtPrefix) {
+        translateExpressionInternal(expr.value)
         when(expr.operator) {
             "+" -> {}
             "-" -> {
-                when(type) {
+                when(expr.type) {
                     in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.neg_b")
                     in WordDatatypes -> asmgen.out("  jsr  prog8_lib.neg_w")
                     DataType.FLOAT -> asmgen.out("  jsr  floats.neg_f")
@@ -714,7 +707,7 @@ internal class ExpressionsAsmGen(private val program: Program,
                 }
             }
             "~" -> {
-                when(type) {
+                when(expr.type) {
                     in ByteDatatypes ->
                         asmgen.out("""
                             lda  P8ESTACK_LO+1,x
@@ -729,22 +722,18 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateExpression(arrayExpr: ArrayIndexedExpression) {
-        val elementIDt = arrayExpr.inferType(program)
-        if(!elementIDt.isKnown)
-            throw AssemblyError("unknown dt")
-        val elementDt = elementIDt.getOr(DataType.UNDEFINED)
-        val arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar)
+    private fun translateExpression(arrayExpr: PtArrayIndexer) {
+        val elementDt = arrayExpr.type
+        val arrayVarName = asmgen.asmVariableName(arrayExpr.variable)
 
-        val arrayVarDecl = arrayExpr.arrayvar.targetVarDecl(program)!!
-        if(arrayVarDecl.datatype==DataType.UWORD) {
+        if(arrayExpr.variable.type==DataType.UWORD) {
             // indexing a pointer var instead of a real array or string
             if(elementDt !in ByteDatatypes)
                 throw AssemblyError("non-array var indexing requires bytes dt")
-            if(arrayExpr.inferType(program) isnot DataType.UBYTE)
+            if(arrayExpr.index.type != DataType.UBYTE)
                 throw AssemblyError("non-array var indexing requires bytes index")
             asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-            if(asmgen.isZpVar(arrayExpr.arrayvar)) {
+            if(asmgen.isZpVar(arrayExpr.variable)) {
                 asmgen.out("  lda  ($arrayVarName),y")
             } else {
                 asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
@@ -754,7 +743,7 @@ internal class ExpressionsAsmGen(private val program: Program,
             return
         }
 
-        val constIndexNum = arrayExpr.indexer.constIndex()
+        val constIndexNum = arrayExpr.index.asConstInteger()
         if(constIndexNum!=null) {
             val indexValue = constIndexNum * program.memsizer.memorySize(elementDt)
             when(elementDt) {
@@ -881,7 +870,7 @@ internal class ExpressionsAsmGen(private val program: Program,
         }
     }
 
-    private fun translateCompareStrings(s1: Expression, operator: String, s2: Expression) {
+    private fun translateCompareStrings(s1: PtExpression, operator: String, s2: PtExpression) {
         asmgen.assignExpressionToVariable(s1, "prog8_lib.strcmp_expression._arg_s1", DataType.UWORD, null)
         asmgen.assignExpressionToVariable(s2, "prog8_lib.strcmp_expression._arg_s2", DataType.UWORD, null)
         asmgen.out(" jsr  prog8_lib.strcmp_expression")    // result  of compare is in A

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

@@ -0,0 +1,135 @@
+package prog8.codegen.cpu6502
+
+import prog8.code.ast.*
+import prog8.code.core.*
+import kotlin.math.abs
+
+// TODO include this in the node class directly?
+
+internal fun PtExpression.asConstInteger(): Int? =
+    (this as? PtNumber)?.number?.toInt()
+
+
+internal fun PtRange.toConstantIntegerRange(): IntProgression? {
+    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)
+            }
+        }
+    }
+
+    val fromLv = from as? PtNumber
+    val toLv = to as? PtNumber
+    val stepLv = step as? PtNumber
+    if(fromLv==null || toLv==null || stepLv==null)
+        return null
+    val fromVal = fromLv.number.toInt()
+    val toVal = toLv.number.toInt()
+    val stepVal = stepLv.number.toInt()
+    return makeRange(fromVal, toVal, stepVal)
+}
+
+
+fun PtExpression.isSimple(): Boolean {
+    return when(this) {
+        is PtAddressOf -> true
+        is PtArray -> true
+        is PtArrayIndexer -> index is PtNumber || index is PtIdentifier
+        is PtBinaryExpression -> false
+        is PtBuiltinFunctionCall -> name in arrayOf("msb", "lsb", "peek", "peekw", "mkword", "set_carry", "set_irqd", "clear_carry", "clear_irqd")
+        is PtContainmentCheck -> false
+        is PtFunctionCall -> false
+        is PtIdentifier -> true
+        is PtMachineRegister -> true
+        is PtMemoryByte -> address is PtNumber || address is PtIdentifier
+        is PtNumber -> true
+        is PtPrefix -> value.isSimple()
+        is PtRange -> true
+        is PtString -> true
+        is PtTypeCast -> value.isSimple()
+    }
+}
+
+internal fun IPtSubroutine.regXasResult(): Boolean =
+    (this is PtAsmSub) && this.returns.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
+
+internal fun IPtSubroutine.shouldSaveX(): Boolean =
+    this.regXasResult() || (this is PtAsmSub && (CpuRegister.X in this.clobbers || regXasParam()))
+
+internal fun PtAsmSub.regXasParam(): Boolean =
+    parameters.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
+
+internal class KeepAresult(val saveOnEntry: Boolean, val saveOnReturn: Boolean)
+
+internal fun PtAsmSub.shouldKeepA(): KeepAresult {
+    // determine if A's value should be kept when preparing for calling the subroutine, and when returning from it
+
+    // it seems that we never have to save A when calling? will be loaded correctly after setup.
+    // but on return it depends on wether the routine returns something in A.
+    val saveAonReturn = returns.any { it.first.registerOrPair==RegisterOrPair.A || it.first.registerOrPair==RegisterOrPair.AY || it.first.registerOrPair==RegisterOrPair.AX }
+    return KeepAresult(false, saveAonReturn)
+}
+
+internal fun IPtSubroutine.returnsWhatWhere(): List<Pair<RegisterOrStatusflag, DataType>> {
+    when(this) {
+        is PtAsmSub -> {
+            return returns
+        }
+        is PtSub -> {
+            // for non-asm subroutines, determine the return registers based on the type of the return value
+            return if(returntype==null)
+                emptyList()
+            else {
+                val register = when (returntype!!) {
+                    in ByteDatatypes -> RegisterOrStatusflag(RegisterOrPair.A, null)
+                    in WordDatatypes -> RegisterOrStatusflag(RegisterOrPair.AY, null)
+                    DataType.FLOAT -> RegisterOrStatusflag(RegisterOrPair.FAC1, null)
+                    else -> RegisterOrStatusflag(RegisterOrPair.AY, null)
+                }
+                listOf(Pair(register, returntype!!))
+            }
+        }
+    }
+}
+
+internal fun PtExpression.clone(): PtExpression {
+    fun withClonedChildrenFrom(orig: PtExpression, clone: PtExpression): PtExpression {
+        orig.children.forEach { clone.add((it as PtExpression).clone()) }
+        return clone
+    }
+    when(this) {
+        is PtAddressOf -> return withClonedChildrenFrom(this, PtAddressOf(position))
+        is PtArray -> return withClonedChildrenFrom(this, PtArray(type, position))
+        is PtArrayIndexer -> return withClonedChildrenFrom(this, PtArrayIndexer(type, position))
+        is PtBinaryExpression -> return withClonedChildrenFrom(this, PtBinaryExpression(operator, type, position))
+        is PtBuiltinFunctionCall -> return withClonedChildrenFrom(this, PtBuiltinFunctionCall(name, void, hasNoSideEffects, type, position))
+        is PtContainmentCheck -> return withClonedChildrenFrom(this, PtContainmentCheck(position))
+        is PtFunctionCall -> return withClonedChildrenFrom(this, PtFunctionCall(name, void, type, position))
+        is PtIdentifier -> return withClonedChildrenFrom(this, PtIdentifier(name, type, position))
+        is PtMachineRegister -> return withClonedChildrenFrom(this, PtMachineRegister(register, type, position))
+        is PtMemoryByte -> return withClonedChildrenFrom(this, PtMemoryByte(position))
+        is PtNumber -> return withClonedChildrenFrom(this, PtNumber(type, number, position))
+        is PtPrefix -> return withClonedChildrenFrom(this, PtPrefix(operator, type, position))
+        is PtRange -> return withClonedChildrenFrom(this, PtRange(type, position))
+        is PtString -> return withClonedChildrenFrom(this, PtString(value, encoding, position))
+        is PtTypeCast -> return withClonedChildrenFrom(this, PtTypeCast(type, position))
+    }
+}
+
+internal fun PtSub.returnRegister(): RegisterOrStatusflag? {
+    return when(returntype) {
+        in ByteDatatypes -> RegisterOrStatusflag(RegisterOrPair.A, null)
+        in WordDatatypes -> RegisterOrStatusflag(RegisterOrPair.AY, null)
+        DataType.FLOAT -> RegisterOrStatusflag(RegisterOrPair.FAC1, null)
+        null -> null
+        else -> RegisterOrStatusflag(RegisterOrPair.AY, null)
+    }
+}

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

@@ -1,46 +1,43 @@
 package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
-import prog8.ast.Program
-import prog8.ast.expressions.IdentifierReference
-import prog8.ast.expressions.RangeExpression
-import prog8.ast.statements.ForLoop
+import prog8.code.ast.*
 import prog8.code.core.*
 import kotlin.math.absoluteValue
 
-internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen, private val zeropage: Zeropage) {
+internal class ForLoopsAsmGen(private val program: PtProgram,
+                              private val asmgen: AsmGen6502Internal,
+                              private val zeropage: Zeropage) {
 
-    internal fun translate(stmt: ForLoop) {
-        val iterableDt = stmt.iterable.inferType(program)
-        if(!iterableDt.isKnown)
-            throw AssemblyError("unknown dt")
+    internal fun translate(stmt: PtForLoop) {
+        val iterableDt = stmt.iterable.type
         when(stmt.iterable) {
-            is RangeExpression -> {
-                val range = (stmt.iterable as RangeExpression).toConstantIntegerRange()
+            is PtRange -> {
+                val range = (stmt.iterable as PtRange).toConstantIntegerRange()
                 if(range==null) {
-                    translateForOverNonconstRange(stmt, iterableDt.getOrElse { throw AssemblyError("unknown dt") }, stmt.iterable as RangeExpression)
+                    translateForOverNonconstRange(stmt, iterableDt, stmt.iterable as PtRange)
                 } else {
-                    translateForOverConstRange(stmt, iterableDt.getOrElse { throw AssemblyError("unknown dt") }, range)
+                    translateForOverConstRange(stmt, iterableDt, range)
                 }
             }
-            is IdentifierReference -> {
-                translateForOverIterableVar(stmt, iterableDt.getOrElse { throw AssemblyError("unknown dt") }, stmt.iterable as IdentifierReference)
+            is PtIdentifier -> {
+                translateForOverIterableVar(stmt, iterableDt, stmt.iterable as PtIdentifier)
             }
             else -> throw AssemblyError("can't iterate over ${stmt.iterable.javaClass} - should have been replaced by a variable")
         }
     }
 
-    private fun translateForOverNonconstRange(stmt: ForLoop, iterableDt: DataType, range: RangeExpression) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
-        val modifiedLabel = program.makeLabel("for_modified")
-        val modifiedLabel2 = program.makeLabel("for_modifiedb")
+    private fun translateForOverNonconstRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        val modifiedLabel = asmgen.makeLabel("for_modified")
+        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
         asmgen.loopEndLabels.push(endLabel)
-        val stepsize=range.step.constValue(program)!!.number.toInt()
+        val stepsize=range.step.asConstInteger()!!
 
         if(stepsize < -1) {
-            val limit = range.to.constValue(program)?.number
-            if(limit==0.0)
+            val limit = range.to.asConstInteger()
+            if(limit==0)
                 throw AssemblyError("for unsigned loop variable it's not possible to count down with step != -1 from a non-const value to exactly zero due to value wrapping")
         }
 
@@ -52,11 +49,11 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
 
                     val incdec = if(stepsize==1) "inc" else "dec"
                     // loop over byte range via loopvar
-                    val varname = asmgen.asmVariableName(stmt.loopVar)
+                    val varname = asmgen.asmVariableName(stmt.variable)
                     asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt), null)
                     asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt), null)
                     asmgen.out(loopLabel)
-                    asmgen.translate(stmt.body)
+                    asmgen.translate(stmt.statements)
                     asmgen.out("""
                         lda  $varname
 $modifiedLabel          cmp  #0         ; modified 
@@ -70,11 +67,11 @@ $modifiedLabel          cmp  #0         ; modified
                     // bytes, step >= 2 or <= -2
 
                     // loop over byte range via loopvar
-                    val varname = asmgen.asmVariableName(stmt.loopVar)
+                    val varname = asmgen.asmVariableName(stmt.variable)
                     asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt), null)
                     asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt), null)
                     asmgen.out(loopLabel)
-                    asmgen.translate(stmt.body)
+                    asmgen.translate(stmt.statements)
                     if(stepsize>0) {
                         asmgen.out("""
                             lda  $varname
@@ -102,14 +99,14 @@ $modifiedLabel              cmp  #0     ; modified
                     // words, step 1 or -1
 
                     stepsize == 1 || stepsize == -1 -> {
-                        val varname = asmgen.asmVariableName(stmt.loopVar)
+                        val varname = asmgen.asmVariableName(stmt.variable)
                         assignLoopvar(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
 $loopLabel""")
-                        asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.statements)
                         asmgen.out("""
                 lda  $varname+1
 $modifiedLabel  cmp  #0    ; modified 
@@ -136,14 +133,14 @@ $modifiedLabel2 cmp  #0    ; modified
                     stepsize > 0 -> {
 
                         // (u)words, step >= 2
-                        val varname = asmgen.asmVariableName(stmt.loopVar)
+                        val varname = asmgen.asmVariableName(stmt.variable)
                         assignLoopvar(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
 $loopLabel""")
-                        asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.statements)
 
                         if (iterableDt == DataType.ARRAY_UW) {
                             asmgen.out("""
@@ -184,14 +181,14 @@ $endLabel""")
                     else -> {
 
                         // (u)words, step <= -2
-                        val varname = asmgen.asmVariableName(stmt.loopVar)
+                        val varname = asmgen.asmVariableName(stmt.variable)
                         assignLoopvar(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
 $loopLabel""")
-                        asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.statements)
 
                         if(iterableDt==DataType.ARRAY_UW) {
                             asmgen.out("""
@@ -237,12 +234,18 @@ $endLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForOverIterableVar(stmt: ForLoop, iterableDt: DataType, ident: IdentifierReference) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+    private fun translateForOverIterableVar(stmt: PtForLoop, iterableDt: DataType, ident: PtIdentifier) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
         val iterableName = asmgen.asmVariableName(ident)
-        val decl = ident.targetVarDecl(program)!!
+        val symbol = asmgen.symbolTable.lookup(ident.name)
+        val decl = symbol!!.astNode as IPtVariable
+        val numElements = when(decl) {
+            is PtConstant -> throw AssemblyError("length of non-array requested")
+            is PtMemMapped -> decl.arraySize
+            is PtVariable -> decl.arraySize
+        }
         when(iterableDt) {
             DataType.STR -> {
                 asmgen.out("""
@@ -252,8 +255,8 @@ $endLabel""")
                     sty  $loopLabel+2
 $loopLabel          lda  ${65535.toHex()}       ; modified
                     beq  $endLabel
-                    sta  ${asmgen.asmVariableName(stmt.loopVar)}""")
-                asmgen.translate(stmt.body)
+                    sta  ${asmgen.asmVariableName(stmt.variable)}""")
+                asmgen.translate(stmt.statements)
                 asmgen.out("""
                     inc  $loopLabel+1
                     bne  $loopLabel
@@ -262,19 +265,18 @@ $loopLabel          lda  ${65535.toHex()}       ; modified
 $endLabel""")
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                val length = decl.arraysize!!.constIndex()!!
-                val indexVar = program.makeLabel("for_index")
+                val indexVar = asmgen.makeLabel("for_index")
                 asmgen.out("""
                     ldy  #0
 $loopLabel          sty  $indexVar
                     lda  $iterableName,y
-                    sta  ${asmgen.asmVariableName(stmt.loopVar)}""")
-                asmgen.translate(stmt.body)
-                if(length<=255) {
+                    sta  ${asmgen.asmVariableName(stmt.variable)}""")
+                asmgen.translate(stmt.statements)
+                if(numElements!!<=255u) {
                     asmgen.out("""
                         ldy  $indexVar
                         iny
-                        cpy  #$length
+                        cpy  #$numElements
                         beq  $endLabel
                         bne  $loopLabel""")
                 } else {
@@ -285,7 +287,7 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(length>=16) {
+                if(numElements>=16u) {
                     // allocate index var on ZP if possible
                     val result = zeropage.allocate(listOf(indexVar), DataType.UBYTE, null, stmt.position, asmgen.errors)
                     result.fold(
@@ -298,9 +300,9 @@ $loopLabel          sty  $indexVar
                 asmgen.out(endLabel)
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                val length = decl.arraysize!!.constIndex()!! * 2
-                val indexVar = program.makeLabel("for_index")
-                val loopvarName = asmgen.asmVariableName(stmt.loopVar)
+                val length = numElements!! * 2u
+                val indexVar = asmgen.makeLabel("for_index")
+                val loopvarName = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
                     ldy  #0
 $loopLabel          sty  $indexVar
@@ -308,8 +310,8 @@ $loopLabel          sty  $indexVar
                     sta  $loopvarName
                     lda  $iterableName+1,y
                     sta  $loopvarName+1""")
-                asmgen.translate(stmt.body)
-                if(length<=127) {
+                asmgen.translate(stmt.statements)
+                if(length<=127u) {
                     asmgen.out("""
                         ldy  $indexVar
                         iny
@@ -326,7 +328,7 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(length>=16) {
+                if(length>=16u) {
                     // allocate index var on ZP if possible
                     val result = zeropage.allocate(listOf(indexVar), DataType.UBYTE, null, stmt.position, asmgen.errors)
                     result.fold(
@@ -346,7 +348,7 @@ $loopLabel          sty  $indexVar
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForOverConstRange(stmt: ForLoop, iterableDt: DataType, range: IntProgression) {
+    private fun translateForOverConstRange(stmt: PtForLoop, iterableDt: DataType, range: IntProgression) {
         if (range.isEmpty() || range.step==0)
             throw AssemblyError("empty range or step 0")
         if(iterableDt==DataType.ARRAY_B || iterableDt==DataType.ARRAY_UB) {
@@ -359,18 +361,18 @@ $loopLabel          sty  $indexVar
         }
 
         // not one of the easy cases, generate more complex code...
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
         when(iterableDt) {
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
                 // loop over byte range via loopvar, step >= 2 or <= -2
-                val varname = asmgen.asmVariableName(stmt.loopVar)
+                val varname = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
                             lda  #${range.first}
                             sta  $varname
 $loopLabel""")
-                asmgen.translate(stmt.body)
+                asmgen.translate(stmt.statements)
                 when (range.step) {
                     0, 1, -1 -> {
                         throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
@@ -430,7 +432,7 @@ $loopLabel""")
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
                 // loop over word range via loopvar, step >= 2 or <= -2
-                val varname = asmgen.asmVariableName(stmt.loopVar)
+                val varname = asmgen.asmVariableName(stmt.variable)
                 when (range.step) {
                     0, 1, -1 -> {
                         throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
@@ -444,7 +446,7 @@ $loopLabel""")
                             sta  $varname
                             sty  $varname+1
 $loopLabel""")
-                        asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.statements)
                         asmgen.out("""
                             lda  $varname
                             cmp  #<${range.last}
@@ -470,16 +472,16 @@ $loopLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForSimpleByteRangeAsc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+    private fun translateForSimpleByteRangeAsc(stmt: PtForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
-        val varname = asmgen.asmVariableName(stmt.loopVar)
+        val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
                 lda  #${range.first}
                 sta  $varname
 $loopLabel""")
-        asmgen.translate(stmt.body)
+        asmgen.translate(stmt.statements)
         if (range.last == 255) {
             asmgen.out("""
                 inc  $varname
@@ -496,16 +498,16 @@ $endLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForSimpleByteRangeDesc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+    private fun translateForSimpleByteRangeDesc(stmt: PtForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
-        val varname = asmgen.asmVariableName(stmt.loopVar)
+        val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
                     lda  #${range.first}
                     sta  $varname
 $loopLabel""")
-        asmgen.translate(stmt.body)
+        asmgen.translate(stmt.statements)
         when (range.last) {
             0 -> {
                 asmgen.out("""
@@ -533,18 +535,18 @@ $endLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForSimpleWordRangeAsc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+    private fun translateForSimpleWordRangeAsc(stmt: PtForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
-        val varname = asmgen.asmVariableName(stmt.loopVar)
+        val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
             lda  #<${range.first}
             ldy  #>${range.first}
             sta  $varname
             sty  $varname+1
 $loopLabel""")
-        asmgen.translate(stmt.body)
+        asmgen.translate(stmt.statements)
         asmgen.out("""
             lda  $varname
             cmp  #<${range.last}
@@ -560,18 +562,18 @@ $loopLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun translateForSimpleWordRangeDesc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = program.makeLabel("for_loop")
-        val endLabel = program.makeLabel("for_end")
+    private fun translateForSimpleWordRangeDesc(stmt: PtForLoop, range: IntProgression) {
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
-        val varname = asmgen.asmVariableName(stmt.loopVar)
+        val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
             lda  #<${range.first}
             ldy  #>${range.first}
             sta  $varname
             sty  $varname+1
 $loopLabel""")
-        asmgen.translate(stmt.body)
+        asmgen.translate(stmt.statements)
         asmgen.out("""
             lda  $varname
             cmp  #<${range.last}
@@ -588,10 +590,10 @@ $loopLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun assignLoopvar(stmt: ForLoop, range: RangeExpression) =
+    private fun assignLoopvar(stmt: PtForLoop, range: PtRange) =
         asmgen.assignExpressionToVariable(
             range.from,
-            asmgen.asmVariableName(stmt.loopVar),
-            stmt.loopVarDt(program).getOrElse { throw AssemblyError("unknown dt") },
-            stmt.definingSubroutine)
+            asmgen.asmVariableName(stmt.variable),
+            stmt.variable.type,
+            stmt.definingISub())
 }

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

@@ -1,16 +1,6 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.IFunctionCall
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.expressions.AddressOf
-import prog8.ast.expressions.Expression
-import prog8.ast.expressions.IdentifierReference
-import prog8.ast.expressions.NumericLiteral
-import prog8.ast.statements.FunctionCallStatement
-import prog8.ast.statements.InlineAssembly
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.SubroutineParameter
+import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignSource
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
@@ -18,51 +8,60 @@ import prog8.codegen.cpu6502.assignment.AsmAssignment
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
 
 
-internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
+internal class FunctionCallAsmGen(private val program: PtProgram, private val asmgen: AsmGen6502Internal) {
 
-    internal fun translateFunctionCallStatement(stmt: FunctionCallStatement) {
+    internal fun translateFunctionCallStatement(stmt: PtFunctionCall) {
         saveXbeforeCall(stmt)
-        translateFunctionCall(stmt, false)
+        translateFunctionCall(stmt)
         restoreXafterCall(stmt)
         // just ignore any result values from the function call.
     }
 
-    internal fun saveXbeforeCall(stmt: IFunctionCall) {
-        val sub = stmt.target.targetSubroutine(program) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
+    internal fun saveXbeforeCall(stmt: PtFunctionCall) {
+        val symbol = asmgen.symbolTable.lookup(stmt.name)
+        val sub = symbol!!.astNode as IPtSubroutine
         if(sub.shouldSaveX()) {
-            val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
+            if(sub is PtAsmSub) {
+                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
                 if (regSaveOnStack)
                     asmgen.saveRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnEntry)
                 else
-                asmgen.saveRegisterLocal(CpuRegister.X, (stmt as Node).definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
+            } else
+                asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
         }
     }
 
-    internal fun restoreXafterCall(stmt: IFunctionCall) {
-        val sub = stmt.target.targetSubroutine(program) ?: throw AssemblyError("undefined subroutine ${stmt.target}")
+    internal fun restoreXafterCall(stmt: PtFunctionCall) {
+        val symbol = asmgen.symbolTable.lookup(stmt.name)
+        val sub = symbol!!.astNode as IPtSubroutine
         if(sub.shouldSaveX()) {
-            val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
+            if(sub is PtAsmSub) {
+                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
                 if (regSaveOnStack)
                     asmgen.restoreRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnReturn)
                 else
                     asmgen.restoreRegisterLocal(CpuRegister.X)
+            } else
+                asmgen.restoreRegisterLocal(CpuRegister.X)
         }
     }
 
-    internal fun optimizeIntArgsViaRegisters(sub: Subroutine) =
+    internal fun optimizeIntArgsViaRegisters(sub: PtSub) =
         (sub.parameters.size==1 && sub.parameters[0].type in IntegerDatatypes)
                 || (sub.parameters.size==2 && sub.parameters[0].type in ByteDatatypes && sub.parameters[1].type in ByteDatatypes)
 
-    internal fun translateFunctionCall(call: IFunctionCall, isExpression: Boolean) {            // TODO remove isExpression unused parameter
+    internal fun translateFunctionCall(call: PtFunctionCall) {
         // Output only the code to set up the parameters and perform the actual call
         // NOTE: does NOT output the code to deal with the result values!
         // NOTE: does NOT output code to save/restore the X register for this call! Every caller should deal with this in their own way!!
         //       (you can use subroutine.shouldSaveX() and saveX()/restoreX() routines as a help for this)
 
-        val sub = call.target.targetSubroutine(program) ?: throw AssemblyError("undefined subroutine ${call.target}")
-        val subAsmName = asmgen.asmSymbolName(call.target)
+        val symbol = asmgen.symbolTable.lookup(call.name)
+        val sub = symbol!!.astNode as IPtSubroutine
+        val subAsmName = asmgen.asmSymbolName(call.name)
 
-        if(sub.isAsmSubroutine) {
+        if(sub is PtAsmSub) {
             argumentsViaRegisters(sub, call)
             if (sub.inline && asmgen.options.optimize) {
                 // inline the subroutine.
@@ -70,16 +69,13 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                 // NOTE: *if* there is a return statement, it will be the only one, and the very last statement of the subroutine
                 // (this condition has been enforced by an ast check earlier)
                 asmgen.out("  \t; inlined routine follows: ${sub.name}")
-                sub.statements.forEach { asmgen.translate(it as InlineAssembly) }
+                sub.children.forEach { asmgen.translate(it as PtInlineAssembly) }
                 asmgen.out("  \t; inlined routine end: ${sub.name}")
             } else {
                 asmgen.out("  jsr  $subAsmName")
             }
         }
-        else {
-            if(sub.inline)
-                throw AssemblyError("can only reliably inline asmsub routines at this time")
-
+        else if(sub is PtSub) {
             if(optimizeIntArgsViaRegisters(sub)) {
                 if(sub.parameters.size==1) {
                     val register = if (sub.parameters[0].type in ByteDatatypes) RegisterOrPair.A else RegisterOrPair.AY
@@ -100,84 +96,82 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             }
             asmgen.out("  jsr  $subAsmName")
         }
+        else throw AssemblyError("invalid sub type")
 
         // remember: dealing with the X register and/or dealing with return values is the responsibility of the caller
     }
 
-    private fun argumentsViaRegisters(sub: Subroutine, call: IFunctionCall) {
+    private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
         if(sub.parameters.size==1) {
-            argumentViaRegister(sub, IndexedValue(0, sub.parameters.single()), call.args[0])
+            argumentViaRegister(sub, IndexedValue(0, sub.parameters.single().second), call.args[0])
         } else {
-            if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.asmParameterRegisters)) {
+            if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.parameters)) {
                 registerArgsViaCpuStackEvaluation(call, sub)
             } else {
                 asmsub6502ArgsEvalOrder(sub).forEach {
                     val param = sub.parameters[it]
                     val arg = call.args[it]
-                    argumentViaRegister(sub, IndexedValue(it, param), arg)
+                    argumentViaRegister(sub, IndexedValue(it, param.second), arg)
                 }
             }
         }
     }
 
-    private fun registerArgsViaCpuStackEvaluation(call: IFunctionCall, callee: Subroutine) {
+    private fun registerArgsViaCpuStackEvaluation(call: PtFunctionCall, callee: PtAsmSub) {
         // this is called when one or more of the arguments are 'complex' and
         // cannot be assigned to a register easily or risk clobbering other registers.
 
-        require(callee.isAsmSubroutine) { "register args only for asm subroutine ${callee.position}" }
         if(callee.parameters.isEmpty())
             return
 
         // use the cpu hardware stack as intermediate storage for the arguments.
         val argOrder = asmsub6502ArgsEvalOrder(callee)
         argOrder.reversed().forEach {
-            asmgen.pushCpuStack(callee.parameters[it].type, call.args[it])
+            asmgen.pushCpuStack(callee.parameters[it].second.type, call.args[it])
         }
         argOrder.forEach {
             val param = callee.parameters[it]
-            val targetVar = callee.searchParameter(param.name)!!
-            asmgen.popCpuStack(param.type, targetVar, (call as Node).definingSubroutine)
+            asmgen.popCpuStack(callee, param.second, param.first)
         }
     }
 
-    private fun argumentViaVariable(sub: Subroutine, parameter: SubroutineParameter, value: Expression) {
+    private fun argumentViaVariable(sub: PtSub, parameter: PtSubroutineParameter, value: PtExpression) {
         // pass parameter via a regular variable (not via registers)
-        val valueIDt = value.inferType(program)
-        val valueDt = valueIDt.getOrElse { throw AssemblyError("unknown dt") }
-        if(!isArgumentTypeCompatible(valueDt, parameter.type))
+        if(!isArgumentTypeCompatible(value.type, parameter.type))
             throw AssemblyError("argument type incompatible")
 
-        val varName = asmgen.asmVariableName(sub.scopedName + parameter.name)
+        val varName = asmgen.asmVariableName(sub.scopedName + "." + parameter.name)
         asmgen.assignExpressionToVariable(value, varName, parameter.type, sub)
     }
 
-    private fun argumentViaRegister(sub: Subroutine, parameter: IndexedValue<SubroutineParameter>, value: Expression, registerOverride: RegisterOrPair? = null) {
+    private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null) {
         // pass argument via a register parameter
-        val valueIDt = value.inferType(program)
-        val valueDt = valueIDt.getOrElse { throw AssemblyError("unknown dt") }
-        if(!isArgumentTypeCompatible(valueDt, parameter.value.type))
+        if(!isArgumentTypeCompatible(value.type, parameter.value.type))
             throw AssemblyError("argument type incompatible")
 
-        val paramRegister = if(registerOverride==null) sub.asmParameterRegisters[parameter.index] else RegisterOrStatusflag(registerOverride, null)
+        val paramRegister: RegisterOrStatusflag = when(sub) {
+            is PtAsmSub -> if(registerOverride==null) sub.parameters[parameter.index].first else RegisterOrStatusflag(registerOverride, null)
+            is PtSub -> RegisterOrStatusflag(registerOverride!!, null)
+        }
         val statusflag = paramRegister.statusflag
         val register = paramRegister.registerOrPair
         val requiredDt = parameter.value.type
-        if(requiredDt!=valueDt) {
-            if(valueDt largerThan requiredDt)
+        if(requiredDt!=value.type) {
+            if(value.type largerThan requiredDt)
                 throw AssemblyError("can only convert byte values to word param types")
         }
         if (statusflag!=null) {
-            if(requiredDt!=valueDt)
+            if(requiredDt!=value.type)
                 throw AssemblyError("for statusflag, byte value is required")
             if (statusflag == Statusflag.Pc) {
                 // this param needs to be set last, right before the jsr
                 // for now, this is already enforced on the subroutine definition by the Ast Checker
                 when(value) {
-                    is NumericLiteral -> {
+                    is PtNumber -> {
                         val carrySet = value.number.toInt() != 0
                         asmgen.out(if(carrySet) "  sec" else "  clc")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val sourceName = asmgen.asmVariableName(value)
                         asmgen.out("""
                             pha
@@ -202,10 +196,10 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         else {
             // via register or register pair
             register!!
-            if(requiredDt largerThan valueDt) {
+            if(requiredDt largerThan value.type) {
                 // we need to sign extend the source, do this via temporary word variable
                 asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", DataType.UBYTE, sub)
-                asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", valueDt)
+                asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", value.type)
                 asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register)
             } else {
                 val target: AsmAssignTarget =
@@ -215,9 +209,11 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                         val signed = parameter.value.type == DataType.BYTE || parameter.value.type == DataType.WORD
                         AsmAssignTarget.fromRegisters(register, signed, sub, asmgen)
                     }
-                val src = if(valueDt in PassByReferenceDatatypes) {
-                    if(value is IdentifierReference) {
-                        val addr = AddressOf(value, Position.DUMMY)
+                val src = if(value.type in PassByReferenceDatatypes) {
+                    if(value is PtIdentifier) {
+                        val addr = PtAddressOf(Position.DUMMY)
+                        addr.add(value)
+                        addr.parent = sub as PtNode
                         AsmAssignSource.fromAstSource(addr, program, asmgen).adjustSignedUnsigned(target)
                     } else {
                         AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)

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

@@ -1,23 +1,23 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.Program
-import prog8.ast.expressions.IdentifierReference
-import prog8.ast.expressions.NumericLiteral
-import prog8.ast.statements.PostIncrDecr
+import prog8.code.ast.PtIdentifier
+import prog8.code.ast.PtNumber
+import prog8.code.ast.PtPostIncrDecr
+import prog8.code.ast.PtProgram
 import prog8.code.core.*
 
 
-internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {
-    internal fun translate(stmt: PostIncrDecr) {
+internal class PostIncrDecrAsmGen(private val program: PtProgram, private val asmgen: AsmGen6502Internal) {
+    internal fun translate(stmt: PtPostIncrDecr) {
         val incr = stmt.operator=="++"
         val targetIdent = stmt.target.identifier
-        val targetMemory = stmt.target.memoryAddress
-        val targetArrayIdx = stmt.target.arrayindexed
-        val scope = stmt.definingSubroutine
+        val targetMemory = stmt.target.memory
+        val targetArrayIdx = stmt.target.array
+        val scope = stmt.definingISub()
         when {
             targetIdent!=null -> {
                 val what = asmgen.asmVariableName(targetIdent)
-                when (stmt.target.inferType(program).getOr(DataType.UNDEFINED)) {
+                when (stmt.target.type) {
                     in ByteDatatypes -> asmgen.out(if (incr) "  inc  $what" else "  dec  $what")
                     in WordDatatypes -> {
                         if(incr)
@@ -38,12 +38,12 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                 }
             }
             targetMemory!=null -> {
-                when (val addressExpr = targetMemory.addressExpression) {
-                    is NumericLiteral -> {
+                when (val addressExpr = targetMemory.address) {
+                    is PtNumber -> {
                         val what = addressExpr.number.toHex()
                         asmgen.out(if(incr) "  inc  $what" else "  dec  $what")
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val what = asmgen.asmVariableName(addressExpr)
                         asmgen.out("  lda  $what |  sta  (+) +1 |  lda  $what+1 |  sta  (+) +2")
                         if(incr)
@@ -62,9 +62,9 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                 }
             }
             targetArrayIdx!=null -> {
-                val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.arrayvar)
-                val elementDt = targetArrayIdx.inferType(program).getOr(DataType.UNDEFINED)
-                val constIndex = targetArrayIdx.indexer.constIndex()
+                val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.variable)
+                val elementDt = targetArrayIdx.type
+                val constIndex = targetArrayIdx.index.asConstInteger()
                 if(constIndex!=null) {
                     val indexValue = constIndex * program.memsizer.memorySize(elementDt)
                     when(elementDt) {

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

@@ -1,12 +1,10 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.Program
-import prog8.ast.statements.*
 import prog8.code.*
+import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
-import prog8.compiler.CallGraph
 import java.time.LocalDate
 import java.time.LocalDateTime
 import kotlin.math.absoluteValue
@@ -20,30 +18,26 @@ import kotlin.math.absoluteValue
  *  - all variables (note: VarDecl ast nodes are *NOT* used anymore for this! now uses IVariablesAndConsts data tables!)
  */
 internal class ProgramAndVarsGen(
-    val program: Program,
+    val program: PtProgram,
     val options: CompilationOptions,
     val errors: IErrorReporter,
     private val symboltable: SymbolTable,
     private val functioncallAsmGen: FunctionCallAsmGen,
-    private val asmgen: AsmGen,
+    private val asmgen: AsmGen6502Internal,
     private val allocator: VariableAllocator,
     private val zeropage: Zeropage
 ) {
     private val compTarget = options.compTarget
-    private val callGraph = CallGraph(program, true)
-    private val blockVariableInitializers = program.allBlocks.associateWith { it.statements.filterIsInstance<Assignment>() }
+    private val blockVariableInitializers = program.allBlocks().associateWith { it.children.filterIsInstance<PtAssignment>() }
 
     internal fun generate() {
-        val allInitializers = blockVariableInitializers.asSequence().flatMap { it.value }
-        require(allInitializers.all { it.origin==AssignmentOrigin.VARINIT }) {"all block-level assignments must be a variable initializer"}
-
         header()
-        val allBlocks = program.allBlocks
+        val allBlocks = program.allBlocks()
         if(allBlocks.first().name != "main")
             throw AssemblyError("first block should be 'main'")
 
         if(errors.noErrors())  {
-            program.allBlocks.forEach { block2asm(it) }
+            program.allBlocks().forEach { block2asm(it) }
 
             // the global list of all floating point constants for the whole program
             asmgen.out("; global float constants")
@@ -100,7 +94,7 @@ internal class ProgramAndVarsGen(
                 when(options.launcher) {
                     CbmPrgLauncherType.BASIC -> {
                         if (options.loadAddress != options.compTarget.machine.PROGRAM_LOAD_ADDRESS) {
-                            errors.err("BASIC output must have load address ${options.compTarget.machine.PROGRAM_LOAD_ADDRESS.toHex()}", program.toplevelModule.position)
+                            errors.err("BASIC output must have load address ${options.compTarget.machine.PROGRAM_LOAD_ADDRESS.toHex()}", program.position)
                         }
                         asmgen.out("; ---- basic program with sys call ----")
                         asmgen.out("* = ${options.loadAddress.toHex()}")
@@ -183,28 +177,28 @@ internal class ProgramAndVarsGen(
         asmgen.out("prog8_program_end\t; end of program label for progend()")
     }
 
-    private fun block2asm(block: Block) {
+    private fun block2asm(block: PtBlock) {
         asmgen.out("")
         asmgen.out("; ---- block: '${block.name}' ----")
         if(block.address!=null)
             asmgen.out("* = ${block.address!!.toHex()}")
         else {
-            if("align_word" in block.options())
+            if(block.alignment==PtBlock.BlockAlignment.WORD)
                 asmgen.out("\t.align 2")
-            else if("align_page" in block.options())
+            else if(block.alignment==PtBlock.BlockAlignment.PAGE)
                 asmgen.out("\t.align $100")
         }
 
-        asmgen.out("${block.name}\t" + (if("force_output" in block.options()) ".block\n" else ".proc\n"))
+        asmgen.out("${block.name}\t" + (if(block.forceOutput) ".block\n" else ".proc\n"))
         asmgen.outputSourceLine(block)
 
         createBlockVariables(block)
-        asmsubs2asm(block.statements)
+        asmsubs2asm(block.children)
 
         asmgen.out("")
 
         val initializers = blockVariableInitializers.getValue(block)
-        val notInitializers = block.statements.filterNot { it in initializers }
+        val notInitializers = block.children.filterNot { it in initializers }
         notInitializers.forEach { asmgen.translate(it) }
 
         if(!options.dontReinitGlobals) {
@@ -216,13 +210,13 @@ internal class ProgramAndVarsGen(
             }
         }
 
-        asmgen.out(if("force_output" in block.options()) "\n\t.bend\n" else "\n\t.pend\n")
+        asmgen.out(if(block.forceOutput) "\n\t.bend\n" else "\n\t.pend\n")
     }
 
     private fun getVars(scope: StNode): Map<String, StNode> =
         scope.children.filter { it.value.type in arrayOf(StNodeType.STATICVAR, StNodeType.CONSTANT, StNodeType.MEMVAR) }
 
-    private fun createBlockVariables(block: Block) {
+    private fun createBlockVariables(block: PtBlock) {
         val scope = symboltable.lookupUnscopedOrElse(block.name) { throw AssemblyError("lookup") }
         require(scope.type==StNodeType.BLOCK)
         val varsInBlock = getVars(scope)
@@ -247,18 +241,10 @@ internal class ProgramAndVarsGen(
         nonZpVariables2asm(variables)
     }
 
-    internal fun translateSubroutine(sub: Subroutine) {
-        var onlyVariables = false
-
+    internal fun translateAsmSubroutine(sub: PtAsmSub) {
         if(sub.inline) {
             if(options.optimize) {
-                if(sub.isAsmSubroutine || callGraph.unused(sub))
                 return
-
-                // from an inlined subroutine only the local variables are generated,
-                // all other code statements are omitted in the subroutine itself
-                // (they've been inlined at the call site, remember?)
-                onlyVariables = true
             }
         }
 
@@ -266,7 +252,7 @@ internal class ProgramAndVarsGen(
 
         val asmStartScope: String
         val asmEndScope: String
-        if(sub.definingBlock.options().contains("force_output")) {
+        if(sub.definingBlock()!!.forceOutput) {
             asmStartScope = ".block"
             asmEndScope = ".bend"
         } else {
@@ -274,19 +260,32 @@ internal class ProgramAndVarsGen(
             asmEndScope = ".pend"
         }
 
-        if(sub.isAsmSubroutine) {
-            if(sub.asmAddress!=null)
+        if(sub.address!=null)
             return  // already done at the memvars section
 
         // asmsub with most likely just an inline asm in it
         asmgen.out("${sub.name}\t$asmStartScope")
-            sub.statements.forEach { asmgen.translate(it) }
+        sub.children.forEach { asmgen.translate(it) }
         asmgen.out("  $asmEndScope\n")
+    }
+
+
+    internal fun translateSubroutine(sub: PtSub) {
+        asmgen.out("")
+
+        val asmStartScope: String
+        val asmEndScope: String
+        if(sub.definingBlock()!!.forceOutput) {
+            asmStartScope = ".block"
+            asmEndScope = ".bend"
         } else {
-            // regular subroutine
+            asmStartScope = ".proc"
+            asmEndScope = ".pend"
+        }
+
         asmgen.out("${sub.name}\t$asmStartScope")
 
-            val scope = symboltable.lookupOrElse(sub.scopedName.joinToString(".")) { throw AssemblyError("lookup") }
+        val scope = symboltable.lookupOrElse(sub.scopedName) { throw AssemblyError("lookup") }
         require(scope.type==StNodeType.SUBROUTINE)
         val varsInSubroutine = getVars(scope)
 
@@ -303,10 +302,10 @@ internal class ProgramAndVarsGen(
             .map { it.value as StConstant }
         memdefsAndConsts2asm(mvs, consts)
 
-            asmsubs2asm(sub.statements)
+        asmsubs2asm(sub.children)
 
         // the main.start subroutine is the program's entrypoint and should perform some initialization logic
-            if(sub.name=="start" && sub.definingBlock.name=="main")
+        if(sub.name=="start" && sub.definingBlock()!!.name=="main")
             entrypointInitialization()
 
         if(functioncallAsmGen.optimizeIntArgsViaRegisters(sub)) {
@@ -328,10 +327,8 @@ internal class ProgramAndVarsGen(
             }
         }
 
-            if(!onlyVariables) {
         asmgen.out("; statements")
-                sub.statements.forEach { asmgen.translate(it) }
-            }
+        sub.children.forEach { asmgen.translate(it) }
 
         asmgen.out("; variables")
         val asmGenInfo = asmgen.subroutineExtra(sub)
@@ -363,7 +360,6 @@ internal class ProgramAndVarsGen(
 
         asmgen.out("  $asmEndScope\n")
     }
-    }
 
     private fun entrypointInitialization() {
         asmgen.out("; program startup initialization")
@@ -593,12 +589,12 @@ internal class ProgramAndVarsGen(
         }
     }
 
-    private fun asmsubs2asm(statements: List<Statement>) {
+    private fun asmsubs2asm(statements: List<PtNode>) {
         statements
-            .filter { it is Subroutine && it.isAsmSubroutine && it.asmAddress!=null }
+            .filter { it is PtAsmSub && it.address!=null }
             .forEach { asmsub ->
-                asmsub as Subroutine
-                asmgen.out("  ${asmsub.name} = ${asmsub.asmAddress!!.toHex()}")
+                asmsub as PtAsmSub
+                asmgen.out("  ${asmsub.name} = ${asmsub.address!!.toHex()}")
             }
     }
 

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

@@ -22,7 +22,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
         allocateZeropageVariables()
     }
 
-    internal fun isZpVar(scopedName: List<String>) = scopedName in zeropageVars
+    internal fun isZpVar(scopedName: List<String>) = scopedName in zeropageVars // TODO as dotted string instead of list?
 
     internal fun getFloatAsmConst(number: Double): String {
         val asmName = globalFloatConsts[number]
@@ -59,7 +59,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                 variable.scopedName.split('.'),
                 variable.dt,
                 variable.length,
-                variable.position,
+                variable.astNode.position,
                 errors
             )
             result.fold(
@@ -67,7 +67,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                     numVariablesAllocatedInZP++
                 },
                 failure = {
-                    errors.err(it.message!!, variable.position)
+                    errors.err(it.message!!, variable.astNode.position)
                 }
             )
         }
@@ -78,7 +78,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                     variable.scopedName.split('.'),
                     variable.dt,
                     variable.length,
-                    variable.position,
+                    variable.astNode.position,
                     errors
                 )
                 result.onSuccess { numVariablesAllocatedInZP++ }
@@ -98,7 +98,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                                 variable.scopedName.split('.'),
                                 variable.dt,
                                 variable.length,
-                                variable.position,
+                                variable.astNode.position,
                                 errors
                             )
                             result.onSuccess { numVariablesAllocatedInZP++ }

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

@@ -1,13 +1,10 @@
 package prog8.codegen.cpu6502.assignment
 
-import prog8.ast.Program
-import prog8.ast.expressions.*
-import prog8.ast.statements.AssignTarget
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.DirectMemoryWrite
-import prog8.ast.statements.Subroutine
+import prog8.code.ast.*
 import prog8.code.core.*
-import prog8.codegen.cpu6502.AsmGen
+import prog8.codegen.cpu6502.AsmGen6502Internal
+import prog8.codegen.cpu6502.asConstInteger
+import prog8.codegen.cpu6502.returnsWhatWhere
 
 
 internal enum class TargetStorageKind {
@@ -29,22 +26,22 @@ internal enum class SourceStorageKind {
 }
 
 internal class AsmAssignTarget(val kind: TargetStorageKind,
-                               private val asmgen: AsmGen,
+                               private val asmgen: AsmGen6502Internal,
                                val datatype: DataType,
-                               val scope: Subroutine?,
+                               val scope: IPtSubroutine?,
                                private val variableAsmName: String? = null,
-                               val array: ArrayIndexedExpression? = null,
-                               val memory: DirectMemoryWrite? = null,
+                               val array: PtArrayIndexer? = null,
+                               val memory: PtMemoryByte? = null,
                                val register: RegisterOrPair? = null,
-                               val origAstTarget: AssignTarget? = null
+                               val origAstTarget: PtAssignTarget? = null
                                )
 {
-    val constArrayIndexValue by lazy { array?.indexer?.constIndex()?.toUInt() }
+    val constArrayIndexValue by lazy { array?.index?.asConstInteger()?.toUInt() }
     val asmVarname: String by lazy {
         if (array == null)
             variableAsmName!!
         else
-            asmgen.asmVariableName(array.arrayvar)
+            asmgen.asmVariableName(array.variable)
     }
 
     lateinit var origAssign: AsmAssignment
@@ -55,33 +52,31 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
     }
 
     companion object {
-        fun fromAstAssignment(assign: Assignment, program: Program, asmgen: AsmGen): AsmAssignTarget {
+        fun fromAstAssignment(assign: PtAssignment, asmgen: AsmGen6502Internal): AsmAssignTarget {
             with(assign.target) {
-                val idt = inferType(program)
-                val dt = idt.getOrElse { throw AssemblyError("unknown dt") }
                 when {
                     identifier != null -> {
-                        val parameter = identifier!!.targetVarDecl(program)?.subroutineParameter
+                        val parameter = asmgen.findSubroutineParameter(identifier!!.name, asmgen)
                         if (parameter!=null) {
-                            val sub = parameter.definingSubroutine!!
-                            if (sub.isAsmSubroutine) {
-                                val reg = sub.asmParameterRegisters[sub.parameters.indexOf(parameter)]
+                            val sub = parameter.definingAsmSub()
+                            if (sub!=null) {
+                                val reg = sub.parameters.single { it.second===parameter }.first
                                 if(reg.statusflag!=null)
                                     throw AssemblyError("can't assign value to processor statusflag directly")
                                 else
-                                    return AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, dt, assign.definingSubroutine, register=reg.registerOrPair, origAstTarget = this)
+                                    return AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, type, assign.definingISub(), register=reg.registerOrPair, origAstTarget = this)
                             }
                         }
-                        return AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, dt, assign.definingSubroutine, variableAsmName = asmgen.asmVariableName(identifier!!), origAstTarget =  this)
+                        return AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, type, assign.definingISub(), variableAsmName = asmgen.asmVariableName(identifier!!), origAstTarget =  this)
                     }
-                    arrayindexed != null -> return AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, dt, assign.definingSubroutine, array = arrayindexed, origAstTarget =  this)
-                    memoryAddress != null -> return AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, dt, assign.definingSubroutine, memory =  memoryAddress, origAstTarget =  this)
+                    array != null -> return AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, type, assign.definingISub(), array = array, origAstTarget =  this)
+                    memory != null -> return AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, type, assign.definingISub(), memory =  memory, origAstTarget =  this)
                     else -> throw AssemblyError("weird target")
                 }
             }
         }
 
-        fun fromRegisters(registers: RegisterOrPair, signed: Boolean, scope: Subroutine?, asmgen: AsmGen): AsmAssignTarget =
+        fun fromRegisters(registers: RegisterOrPair, signed: Boolean, scope: IPtSubroutine?, asmgen: AsmGen6502Internal): AsmAssignTarget =
                 when(registers) {
                     RegisterOrPair.A,
                     RegisterOrPair.X,
@@ -112,69 +107,66 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
 }
 
 internal class AsmAssignSource(val kind: SourceStorageKind,
-                               private val program: Program,
-                               private val asmgen: AsmGen,
+                               private val program: PtProgram,
+                               private val asmgen: AsmGen6502Internal,
                                val datatype: DataType,
                                private val variableAsmName: String? = null,
-                               val array: ArrayIndexedExpression? = null,
-                               val memory: DirectMemoryRead? = null,
+                               val array: PtArrayIndexer? = null,
+                               val memory: PtMemoryByte? = null,
                                val register: RegisterOrPair? = null,
-                               val number: NumericLiteral? = null,
-                               val expression: Expression? = null
+                               val number: PtNumber? = null,
+                               val expression: PtExpression? = null
 )
 {
     val asmVarname: String
         get() = if(array==null)
             variableAsmName!!
         else
-            asmgen.asmVariableName(array.arrayvar)
+            asmgen.asmVariableName(array.variable)
 
     companion object {
-        fun fromAstSource(value: Expression, program: Program, asmgen: AsmGen): AsmAssignSource {
-            val cv = value.constValue(program)
+        fun fromAstSource(value: PtExpression, program: PtProgram, asmgen: AsmGen6502Internal): AsmAssignSource {
+            val cv = value as? PtNumber
             if(cv!=null)
                 return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, asmgen, cv.type, number = cv)
 
             return when(value) {
-                is NumericLiteral -> throw AssemblyError("should have been constant value")
-                is StringLiteral -> throw AssemblyError("string literal value should not occur anymore for asm generation")
-                is ArrayLiteral -> throw AssemblyError("array literal value should not occur anymore for asm generation")
-                is IdentifierReference -> {
-                    val parameter = value.targetVarDecl(program)?.subroutineParameter
-                    if(parameter!=null && parameter.definingSubroutine!!.isAsmSubroutine)
+                // checked above:   is PtNumber -> throw AssemblyError("should have been constant value")
+                is PtString -> throw AssemblyError("string literal value should not occur anymore for asm generation")
+                is PtArray -> throw AssemblyError("array literal value should not occur anymore for asm generation")
+                is PtIdentifier -> {
+                    val parameter = asmgen.findSubroutineParameter(value.name, asmgen)
+                    if(parameter?.definingAsmSub() != null)
                         throw AssemblyError("can't assign from a asmsub register parameter $value ${value.position}")
-                    val dt = value.inferType(program).getOr(DataType.UNDEFINED)
                     val varName=asmgen.asmVariableName(value)
                     // special case: "cx16.r[0-15]" are 16-bits virtual registers of the commander X16 system
-                    if(dt == DataType.UWORD && varName.lowercase().startsWith("cx16.r")) {
+                    if(value.type == DataType.UWORD && varName.lowercase().startsWith("cx16.r")) {
                         val regStr = varName.lowercase().substring(5)
                         val reg = RegisterOrPair.valueOf(regStr.uppercase())
-                        AsmAssignSource(SourceStorageKind.REGISTER, program, asmgen, dt, register = reg)
+                        AsmAssignSource(SourceStorageKind.REGISTER, program, asmgen, value.type, register = reg)
                     } else {
-                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, dt, variableAsmName = varName)
+                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, value.type, variableAsmName = varName)
                     }
                 }
-                is DirectMemoryRead -> {
+                is PtMemoryByte -> {
                     AsmAssignSource(SourceStorageKind.MEMORY, program, asmgen, DataType.UBYTE, memory = value)
                 }
-                is ArrayIndexedExpression -> {
-                    val dt = value.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-                    AsmAssignSource(SourceStorageKind.ARRAY, program, asmgen, dt, array = value)
+                is PtArrayIndexer -> {
+                    AsmAssignSource(SourceStorageKind.ARRAY, program, asmgen, value.type, array = value)
                 }
-                is BuiltinFunctionCall -> {
-                    val returnType = value.inferType(program)
-                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType.getOrElse { throw AssemblyError("unknown dt") }, expression = value)
+                is PtBuiltinFunctionCall -> {
+                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
                 }
-                is FunctionCallExpression -> {
-                    val sub = value.target.targetSubroutine(program)!!
-                    val returnType = sub.returntypes.zip(sub.asmReturnvaluesRegisters).firstOrNull { rr -> rr.second.registerOrPair != null || rr.second.statusflag!=null }?.first
+                is PtFunctionCall -> {
+                    val symbol = asmgen.symbolTable.lookup(value.name)
+                    val sub = symbol!!.astNode as IPtSubroutine
+                    val returnType = sub.returnsWhatWhere().firstOrNull { rr -> rr.first.registerOrPair != null || rr.first.statusflag!=null }?.second
                             ?: throw AssemblyError("can't translate zero return values in assignment")
 
                     AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType, expression = value)
                 }
                 else -> {
-                    val returnType = value.inferType(program)
-                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, returnType.getOrElse { throw AssemblyError("unknown dt") }, expression = value)
+                    AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
                 }
             }
         }
@@ -209,7 +201,7 @@ internal class AsmAssignment(val source: AsmAssignSource,
         if(target.register !in arrayOf(RegisterOrPair.XY, RegisterOrPair.AX, RegisterOrPair.AY))
             require(source.datatype != DataType.UNDEFINED) { "must not be placeholder/undefined datatype at $position" }
             require(memsizer.memorySize(source.datatype) <= memsizer.memorySize(target.datatype)) {
-                "source dt size must be less or equal to target dt size at $position"
+                "source dt size must be less or equal to target dt size at $position srcdt=${source.datatype} targetdt=${target.datatype}"
             }
     }
 }

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

@@ -1,24 +1,19 @@
 package prog8.codegen.cpu6502.assignment
 
-import prog8.ast.Program
-import prog8.ast.expressions.*
-import prog8.ast.statements.*
+import prog8.code.ast.*
 import prog8.code.core.*
-import prog8.codegen.cpu6502.AsmGen
-import prog8.codegen.cpu6502.VariableAllocator
-import prog8.compiler.builtinFunctionReturnType
+import prog8.codegen.cpu6502.*
 
 
-internal class AssignmentAsmGen(private val program: Program, 
-                                private val asmgen: AsmGen, 
+internal class AssignmentAsmGen(private val program: PtProgram,
+                                private val asmgen: AsmGen6502Internal,
                                 private val allocator: VariableAllocator) {
     private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, asmgen, allocator)
 
-    fun translate(assignment: Assignment) {
-        val target = AsmAssignTarget.fromAstAssignment(assignment, program, asmgen)
+    fun translate(assignment: PtAssignment) {
+        val target = AsmAssignTarget.fromAstAssignment(assignment, asmgen)
         val source = AsmAssignSource.fromAstSource(assignment.value, program, asmgen).adjustSignedUnsigned(target)
-
-        val assign = AsmAssignment(source, target, assignment.isAugmentable, program.memsizer, assignment.position)
+        val assign = AsmAssignment(source, target, assignment.isInplaceAssign, program.memsizer, assignment.position)
         target.origAssign = assign
 
         if(assign.isAugmentable)
@@ -64,17 +59,16 @@ internal class AssignmentAsmGen(private val program: Program,
             SourceStorageKind.ARRAY -> {
                 val value = assign.source.array!!
                 val elementDt = assign.source.datatype
-                val arrayVarName = asmgen.asmVariableName(value.arrayvar)
+                val arrayVarName = asmgen.asmVariableName(value.variable)
 
-                val arrayVarDecl = value.arrayvar.targetVarDecl(program)!!
-                if(arrayVarDecl.datatype==DataType.UWORD) {
+                if(value.variable.type==DataType.UWORD) {
                     // indexing a pointer var instead of a real array or string
                     if(elementDt !in ByteDatatypes)
                         throw AssemblyError("non-array var indexing requires bytes dt")
-                    if(value.inferType(program) isnot DataType.UBYTE)
+                    if(value.type != DataType.UBYTE)
                         throw AssemblyError("non-array var indexing requires bytes index")
                     asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
-                    if(asmgen.isZpVar(value.arrayvar)) {
+                    if(asmgen.isZpVar(value.variable)) {
                         asmgen.out("  lda  ($arrayVarName),y")
                     } else {
                         asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
@@ -84,7 +78,7 @@ internal class AssignmentAsmGen(private val program: Program,
                     return
                 }
 
-                val constIndex = value.indexer.constIndex()
+                val constIndex = value.index.asConstInteger()
                 if (constIndex!=null) {
                     // constant array index value
                     val indexValue = constIndex * program.memsizer.memorySize(elementDt)
@@ -133,29 +127,29 @@ internal class AssignmentAsmGen(private val program: Program,
                 }
             }
             SourceStorageKind.MEMORY -> {
-                fun assignViaExprEval(expression: Expression) {
+                fun assignViaExprEval(expression: PtExpression) {
                     assignExpressionToVariable(expression, "P8ZP_SCRATCH_W2", DataType.UWORD, assign.target.scope)
                     asmgen.loadAFromZpPointerVar("P8ZP_SCRATCH_W2")
                     assignRegisterByte(assign.target, CpuRegister.A)
                 }
 
                 val value = assign.source.memory!!
-                when (value.addressExpression) {
-                    is NumericLiteral -> {
-                        val address = (value.addressExpression as NumericLiteral).number.toUInt()
+                when (value.address) {
+                    is PtNumber -> {
+                        val address = (value.address as PtNumber).number.toUInt()
                         assignMemoryByte(assign.target, address, null)
                     }
-                    is IdentifierReference -> {
-                        assignMemoryByte(assign.target, null, value.addressExpression as IdentifierReference)
+                    is PtIdentifier -> {
+                        assignMemoryByte(assign.target, null, value.address as PtIdentifier)
                     }
-                    is BinaryExpression -> {
-                        if(asmgen.tryOptimizedPointerAccessWithA(value.addressExpression as BinaryExpression, false)) {
+                    is PtBinaryExpression -> {
+                        if(asmgen.tryOptimizedPointerAccessWithA(value.address as PtBinaryExpression, false)) {
                             assignRegisterByte(assign.target, CpuRegister.A)
                         } else {
-                            assignViaExprEval(value.addressExpression)
+                            assignViaExprEval(value.address)
                         }
                     }
-                    else -> assignViaExprEval(value.addressExpression)
+                    else -> assignViaExprEval(value.address)
                 }
             }
             SourceStorageKind.EXPRESSION -> {
@@ -173,22 +167,22 @@ internal class AssignmentAsmGen(private val program: Program,
 
     private fun assignExpression(assign: AsmAssignment) {
         when(val value = assign.source.expression!!) {
-            is AddressOf -> {
+            is PtAddressOf -> {
                 val sourceName = asmgen.asmSymbolName(value.identifier)
                 assignAddressOf(assign.target, sourceName)
             }
-            is NumericLiteral -> throw AssemblyError("source kind should have been literalnumber")
-            is IdentifierReference -> throw AssemblyError("source kind should have been variable")
-            is ArrayIndexedExpression -> throw AssemblyError("source kind should have been array")
-            is DirectMemoryRead -> throw AssemblyError("source kind should have been memory")
-            is TypecastExpression -> assignTypeCastedValue(assign.target, value.type, value.expression, value)
-            is FunctionCallExpression -> {
-                val sub = value.target.targetSubroutine(program)!!
+            is PtNumber -> throw AssemblyError("source kind should have been literalnumber")
+            is PtIdentifier -> throw AssemblyError("source kind should have been variable")
+            is PtArrayIndexer -> throw AssemblyError("source kind should have been array")
+            is PtMemoryByte -> throw AssemblyError("source kind should have been memory")
+            is PtTypeCast -> assignTypeCastedValue(assign.target, value.type, value.value, value)
+            is PtFunctionCall -> {
+                val symbol = asmgen.symbolTable.lookup(value.name)
+                val sub = symbol!!.astNode as IPtSubroutine
                 asmgen.saveXbeforeCall(value)
-                asmgen.translateFunctionCall(value, true)
-                val returnValue = sub.returntypes.zip(sub.asmReturnvaluesRegisters).singleOrNull { it.second.registerOrPair!=null } ?:
-                sub.returntypes.zip(sub.asmReturnvaluesRegisters).single { it.second.statusflag!=null }
-                when (returnValue.first) {
+                asmgen.translateFunctionCall(value)
+                val returnValue = sub.returnsWhatWhere().singleOrNull { it.first.registerOrPair!=null } ?: sub.returnsWhatWhere().single { it.first.statusflag!=null }
+                when (returnValue.second) {
                     DataType.STR -> {
                         asmgen.restoreXafterCall(value)
                         when(assign.target.datatype) {
@@ -209,7 +203,7 @@ internal class AssignmentAsmGen(private val program: Program,
                     }
                     else -> {
                         // do NOT restore X register before assigning the result values first
-                        when (returnValue.second.registerOrPair) {
+                        when (returnValue.first.registerOrPair) {
                             RegisterOrPair.A -> assignRegisterByte(assign.target, CpuRegister.A)
                             RegisterOrPair.X -> assignRegisterByte(assign.target, CpuRegister.X)
                             RegisterOrPair.Y -> assignRegisterByte(assign.target, CpuRegister.Y)
@@ -233,7 +227,7 @@ internal class AssignmentAsmGen(private val program: Program,
                             RegisterOrPair.R14 -> assignVirtualRegister(assign.target, RegisterOrPair.R14)
                             RegisterOrPair.R15 -> assignVirtualRegister(assign.target, RegisterOrPair.R15)
                             else -> {
-                                val sflag = returnValue.second.statusflag
+                                val sflag = returnValue.first.statusflag
                                 if(sflag!=null)
                                     assignStatusFlagByte(assign.target, sflag)
                                 else
@@ -245,14 +239,11 @@ internal class AssignmentAsmGen(private val program: Program,
                     }
                 }
             }
-            is BuiltinFunctionCall -> {
-                asmgen.translateBuiltinFunctionCallExpression(value, false, assign.target.register)
+            is PtBuiltinFunctionCall -> {
+                val returnDt = asmgen.translateBuiltinFunctionCallExpression(value, false, assign.target.register)
                 if(assign.target.register==null) {
                     // still need to assign the result to the target variable/etc.
-                    val returntype = builtinFunctionReturnType(value.name)
-                    if(!returntype.isKnown)
-                        throw AssemblyError("unknown dt")
-                    when(returntype.getOr(DataType.UNDEFINED)) {
+                    when(returnDt) {
                         in ByteDatatypes -> assignRegisterByte(assign.target, CpuRegister.A)            // function's byte result is in A
                         in WordDatatypes -> assignRegisterpairWord(assign.target, RegisterOrPair.AY)    // function's word result is in AY
                         DataType.STR -> {
@@ -279,13 +270,13 @@ internal class AssignmentAsmGen(private val program: Program,
                     }
                 }
             }
-            is PrefixExpression -> {
+            is PtPrefix -> {
                 if(assign.target.array==null) {
                     // First assign the value to the target then apply the operator in place on the target.
                     // This saves a temporary variable
                     translateNormalAssignment(
                         AsmAssignment(
-                            AsmAssignSource.fromAstSource(value.expression, program, asmgen),
+                            AsmAssignSource.fromAstSource(value.value, program, asmgen),
                             assign.target,
                             false, program.memsizer, assign.position
                         )
@@ -301,11 +292,11 @@ internal class AssignmentAsmGen(private val program: Program,
                     assignPrefixedExpressionToArrayElt(assign)
                 }
             }
-            is ContainmentCheck -> {
+            is PtContainmentCheck -> {
                 containmentCheckIntoA(value)
                 assignRegisterByte(assign.target, CpuRegister.A)
             }
-            is BinaryExpression -> {
+            is PtBinaryExpression -> {
                 if(!attemptAssignOptimizedBinexpr(value, assign)) {
                     // All remaining binary expressions just evaluate via the stack for now.
                     // (we can't use the assignment helper functions (assignExpressionTo...) to do it via registers here,
@@ -318,7 +309,7 @@ internal class AssignmentAsmGen(private val program: Program,
     }
 
     internal fun assignPrefixedExpressionToArrayElt(assign: AsmAssignment) {
-        require(assign.source.expression is PrefixExpression)
+        require(assign.source.expression is PtPrefix)
         if(assign.source.datatype==DataType.FLOAT) {
             // floatarray[x] = -value   ... just use FAC1 to calculate the expression into and then store that back into the array.
             assignExpressionToRegister(assign.source.expression, RegisterOrPair.FAC1, true)
@@ -350,9 +341,9 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun attemptAssignOptimizedBinexpr(expr: BinaryExpression, assign: AsmAssignment): Boolean {
+    private fun attemptAssignOptimizedBinexpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
         if(expr.operator in ComparisonOperators) {
-            if(expr.right.constValue(program)?.number == 0.0) {
+            if(expr.right.asConstInteger() == 0) {
                 if(expr.operator == "==" || expr.operator=="!=") {
                     when(assign.target.datatype) {
                         in ByteDatatypes -> if(attemptAssignToByteCompareZero(expr, assign)) return true
@@ -365,30 +356,37 @@ internal class AssignmentAsmGen(private val program: Program,
             val origTarget = assign.target.origAstTarget
             if(origTarget!=null) {
                 assignConstantByte(assign.target, 0)
-                val assignTrue = AnonymousScope(mutableListOf(
-                    Assignment(origTarget, NumericLiteral.fromBoolean(true, assign.position), AssignmentOrigin.ASMGEN, assign.position)
-                ), assign.position)
-                val assignFalse = AnonymousScope(mutableListOf(), assign.position)
-                val ifelse = IfElse(expr.copy(), assignTrue, assignFalse, assign.position)
-                ifelse.linkParents(expr)
+                val assignTrue = PtNodeGroup()
+                val assignment = PtAssignment(assign.position)
+                assignment.add(origTarget)
+                assignment.add(PtNumber.fromBoolean(true, assign.position))
+                assignTrue.add(assignment)
+                val assignFalse = PtNodeGroup()
+                val ifelse = PtIfElse(assign.position)
+                val exprClone = PtBinaryExpression(expr.operator, expr.type, expr.position)
+                expr.children.forEach { exprClone.children.add(it) }        // doesn't seem to need a deep clone
+                ifelse.add(exprClone)
+                ifelse.add(assignTrue)
+                ifelse.add(assignFalse)
+                ifelse.parent = expr.parent
                 asmgen.translate(ifelse)
                 return true
             }
         }
 
-        if(!expr.inferType(program).isInteger)
+        if(expr.type !in IntegerDatatypes)
             return false
 
         fun simpleLogicalBytesExpr() {
             // both left and right expression operands are simple.
-            if (expr.right is NumericLiteral || expr.right is IdentifierReference)
+            if (expr.right is PtNumber || expr.right is PtIdentifier)
                 assignLogicalWithSimpleRightOperandByte(assign.target, expr.left, expr.operator, expr.right)
-            else if (expr.left is NumericLiteral || expr.left is IdentifierReference)
+            else if (expr.left is PtNumber || expr.left is PtIdentifier)
                 assignLogicalWithSimpleRightOperandByte(assign.target, expr.right, expr.operator, expr.left)
             else {
                 assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
                 asmgen.saveRegisterStack(CpuRegister.A, false)
-                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE, expr.definingSubroutine)
+                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE, expr.definingISub())
                 asmgen.restoreRegisterStack(CpuRegister.A, false)
                 when (expr.operator) {
                     "&", "and" -> asmgen.out("  and  P8ZP_SCRATCH_B1")
@@ -402,15 +400,15 @@ internal class AssignmentAsmGen(private val program: Program,
 
         fun simpleLogicalWordsExpr() {
             // both left and right expression operands are simple.
-            if (expr.right is NumericLiteral || expr.right is IdentifierReference)
+            if (expr.right is PtNumber || expr.right is PtIdentifier)
                 assignLogicalWithSimpleRightOperandWord(assign.target, expr.left, expr.operator, expr.right)
-            else if (expr.left is NumericLiteral || expr.left is IdentifierReference)
+            else if (expr.left is PtNumber || expr.left is PtIdentifier)
                 assignLogicalWithSimpleRightOperandWord(assign.target, expr.right, expr.operator, expr.left)
             else {
                 assignExpressionToRegister(expr.left, RegisterOrPair.AY, false)
                 asmgen.saveRegisterStack(CpuRegister.A, false)
                 asmgen.saveRegisterStack(CpuRegister.Y, false)
-                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_W1", DataType.UWORD, expr.definingSubroutine)
+                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_W1", DataType.UWORD, expr.definingISub())
                 when (expr.operator) {
                     "&", "and" -> asmgen.out("  pla |  and  P8ZP_SCRATCH_W1+1 |  tay |  pla |  and  P8ZP_SCRATCH_W1")
                     "|", "or" -> asmgen.out("  pla |  ora  P8ZP_SCRATCH_W1+1 |  tay |  pla |  ora  P8ZP_SCRATCH_W1")
@@ -422,14 +420,14 @@ internal class AssignmentAsmGen(private val program: Program,
         }
 
         if(expr.operator in setOf("&", "|", "^", "and", "or", "xor")) {
-            if (expr.left.inferType(program).isBytes && expr.right.inferType(program).isBytes) {
-                if (expr.right.isSimple) {
+            if (expr.left.type in ByteDatatypes && expr.right.type in ByteDatatypes) {
+                if (expr.right.isSimple()) {
                     simpleLogicalBytesExpr()
                     return true
                 }
             }
-            if (expr.left.inferType(program).isWords && expr.right.inferType(program).isWords) {
-                if (expr.right.isSimple) {
+            if (expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
+                if (expr.right.isSimple()) {
                     simpleLogicalWordsExpr()
                     return true
                 }
@@ -439,11 +437,11 @@ internal class AssignmentAsmGen(private val program: Program,
 
         if(expr.operator == "==" || expr.operator == "!=") {
             // expression datatype is BOOL (ubyte) but operands can be anything
-            if(expr.left.inferType(program).isBytes && expr.right.inferType(program).isBytes &&
-                    expr.left.isSimple && expr.right.isSimple) {
+            if(expr.left.type in ByteDatatypes && expr.right.type in ByteDatatypes &&
+                    expr.left.isSimple() && expr.right.isSimple()) {
                 assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
                 asmgen.saveRegisterStack(CpuRegister.A, false)
-                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE, expr.definingSubroutine)
+                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE, expr.definingISub())
                 asmgen.restoreRegisterStack(CpuRegister.A, false)
                 if(expr.operator=="==") {
                     asmgen.out("""
@@ -464,12 +462,12 @@ internal class AssignmentAsmGen(private val program: Program,
                 }
                 assignRegisterByte(assign.target, CpuRegister.A)
                 return true
-            } else if(expr.left.inferType(program).isWords && expr.right.inferType(program).isWords &&
-                    expr.left.isSimple && expr.right.isSimple) {
+            } else if(expr.left.type in WordDatatypes && expr.right.type in WordDatatypes &&
+                    expr.left.isSimple() && expr.right.isSimple()) {
                 assignExpressionToRegister(expr.left, RegisterOrPair.AY, false)
                 asmgen.saveRegisterStack(CpuRegister.A, false)
                 asmgen.saveRegisterStack(CpuRegister.Y, false)
-                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_W1", DataType.UWORD, expr.definingSubroutine)
+                assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_W1", DataType.UWORD, expr.definingISub())
                 asmgen.restoreRegisterStack(CpuRegister.Y, false)
                 asmgen.restoreRegisterStack(CpuRegister.A, false)
                 if(expr.operator=="==") {
@@ -499,12 +497,12 @@ internal class AssignmentAsmGen(private val program: Program,
             return false
         }
         else if(expr.operator=="+" || expr.operator=="-") {
-            val dt = expr.inferType(program).getOrElse { throw AssemblyError("invalid dt") }
+            val dt = expr.type
             val left = expr.left
             val right = expr.right
             if(dt in ByteDatatypes) {
                 when (right) {
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         assignExpressionToRegister(left, RegisterOrPair.A, dt==DataType.BYTE)
                         val symname = asmgen.asmVariableName(right)
                         if(expr.operator=="+")
@@ -514,7 +512,7 @@ internal class AssignmentAsmGen(private val program: Program,
                         assignRegisterByte(assign.target, CpuRegister.A)
                         return true
                     }
-                    is NumericLiteral -> {
+                    is PtNumber -> {
                         assignExpressionToRegister(left, RegisterOrPair.A, dt==DataType.BYTE)
                         if(expr.operator=="+")
                             asmgen.out("  clc |  adc  #${right.number.toHex()}")
@@ -527,7 +525,7 @@ internal class AssignmentAsmGen(private val program: Program,
                 }
             } else if(dt in WordDatatypes) {
                 when (right) {
-                    is AddressOf -> {
+                    is PtAddressOf -> {
                         assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
                         val symbol = asmgen.asmVariableName(right.identifier)
                         if(expr.operator=="+")
@@ -551,7 +549,7 @@ internal class AssignmentAsmGen(private val program: Program,
                         assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                         return true
                     }
-                    is IdentifierReference -> {
+                    is PtIdentifier -> {
                         val symname = asmgen.asmVariableName(right)
                         assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
                         if(expr.operator=="+")
@@ -575,7 +573,7 @@ internal class AssignmentAsmGen(private val program: Program,
                         assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                         return true
                     }
-                    is NumericLiteral -> {
+                    is PtNumber -> {
                         assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
                         if(expr.operator=="+") {
                             asmgen.out("""
@@ -599,10 +597,10 @@ internal class AssignmentAsmGen(private val program: Program,
                         assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                         return true
                     }
-                    is TypecastExpression -> {
-                        val castedValue = right.expression
-                        if(right.type in WordDatatypes && castedValue.inferType(program).isBytes) {
-                            if(castedValue is IdentifierReference) {
+                    is PtTypeCast -> {
+                        val castedValue = right.value
+                        if(right.type in WordDatatypes && castedValue.type in ByteDatatypes) {
+                            if(castedValue is PtIdentifier) {
                                 val castedSymname = asmgen.asmVariableName(castedValue)
                                 assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
                                 if(expr.operator=="+")
@@ -629,11 +627,11 @@ internal class AssignmentAsmGen(private val program: Program,
             }
         }
         else if(expr.operator=="<<" || expr.operator==">>") {
-            val shifts = expr.right.constValue(program)?.number?.toInt()
+            val shifts = expr.right.asConstInteger()
             if(shifts!=null) {
-                val dt = expr.left.inferType(program)
-                if(dt.isBytes && shifts in 0..7) {
-                    val signed = dt istype DataType.BYTE
+                val dt = expr.left.type
+                if(dt in ByteDatatypes && shifts in 0..7) {
+                    val signed = dt == DataType.BYTE
                     assignExpressionToRegister(expr.left, RegisterOrPair.A, signed)
                     if(expr.operator=="<<") {
                         repeat(shifts) {
@@ -650,8 +648,8 @@ internal class AssignmentAsmGen(private val program: Program,
                     }
                     assignRegisterByte(assign.target, CpuRegister.A)
                     return true
-                } else if(dt.isWords && shifts in 0..7) {
-                    val signed = dt istype DataType.WORD
+                } else if(dt in WordDatatypes && shifts in 0..7) {
+                    val signed = dt == DataType.WORD
                     assignExpressionToRegister(expr.left, RegisterOrPair.AY, signed)
                     if(expr.operator=="<<") {
                         if(shifts>0) {
@@ -683,11 +681,11 @@ internal class AssignmentAsmGen(private val program: Program,
         return false
     }
 
-    private fun assignLogicalWithSimpleRightOperandByte(target: AsmAssignTarget, left: Expression, operator: String, right: Expression) {
+    private fun assignLogicalWithSimpleRightOperandByte(target: AsmAssignTarget, left: PtExpression, operator: String, right: PtExpression) {
         assignExpressionToRegister(left, RegisterOrPair.A, false)
         val operand = when(right) {
-            is NumericLiteral -> "#${right.number.toHex()}"
-            is IdentifierReference -> asmgen.asmSymbolName(right)
+            is PtNumber -> "#${right.number.toHex()}"
+            is PtIdentifier -> asmgen.asmSymbolName(right)
             else -> throw AssemblyError("wrong right operand type")
         }
         when (operator) {
@@ -699,10 +697,10 @@ internal class AssignmentAsmGen(private val program: Program,
         assignRegisterByte(target, CpuRegister.A)
     }
 
-    private fun assignLogicalWithSimpleRightOperandWord(target: AsmAssignTarget, left: Expression, operator: String, right: Expression) {
+    private fun assignLogicalWithSimpleRightOperandWord(target: AsmAssignTarget, left: PtExpression, operator: String, right: PtExpression) {
         assignExpressionToRegister(left, RegisterOrPair.AY, false)
         when(right) {
-            is NumericLiteral -> {
+            is PtNumber -> {
                 val number = right.number.toHex()
                 when (operator) {
                     "&", "and" -> asmgen.out("  and  #<$number |  pha |  tya |  and  #>$number |  tay |  pla")
@@ -711,7 +709,7 @@ internal class AssignmentAsmGen(private val program: Program,
                     else -> throw AssemblyError("invalid operator")
                 }
             }
-            is IdentifierReference -> {
+            is PtIdentifier -> {
                 val name = asmgen.asmSymbolName(right)
                 when (operator) {
                     "&", "and" -> asmgen.out("  and  $name |  pha |  tya |  and  $name+1 |  tay |  pla")
@@ -725,10 +723,10 @@ internal class AssignmentAsmGen(private val program: Program,
         assignRegisterpairWord(target, RegisterOrPair.AY)
     }
 
-    private fun attemptAssignToByteCompareZero(expr: BinaryExpression, assign: AsmAssignment): Boolean {
+    private fun attemptAssignToByteCompareZero(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
         when (expr.operator) {
             "==" -> {
-                when(val dt = expr.left.inferType(program).getOrElse { throw AssemblyError("invalid dt") }) {
+                when(val dt = expr.left.type) {
                     in ByteDatatypes -> {
                         assignExpressionToRegister(expr.left, RegisterOrPair.A, dt==DataType.BYTE)
                         asmgen.out("""
@@ -765,7 +763,7 @@ internal class AssignmentAsmGen(private val program: Program,
                 }
             }
             "!=" -> {
-                when(val dt = expr.left.inferType(program).getOrElse { throw AssemblyError("invalid dt") }) {
+                when(val dt = expr.left.type) {
                     in ByteDatatypes -> {
                         assignExpressionToRegister(expr.left, RegisterOrPair.A, dt==DataType.BYTE)
                         asmgen.out("  beq  + |  lda  #1")
@@ -807,65 +805,24 @@ internal class AssignmentAsmGen(private val program: Program,
             assignStackValue(assign.target)
     }
 
-    private fun containmentCheckIntoA(containment: ContainmentCheck) {
-        val elementDt = containment.element.inferType(program)
-        val variable = (containment.iterable as? IdentifierReference)?.targetVarDecl(program)
-            ?: throw AssemblyError("invalid containment iterable type")
-
-        if(variable.origin!=VarDeclOrigin.USERCODE) {
-            when(variable.datatype) {
-                DataType.STR -> {
-                    require(elementDt.isBytes) { "must be byte string ${variable.position}" }
-                    val stringVal = variable.value as StringLiteral
-                    val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
-                    assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                    asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
-                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                    asmgen.restoreRegisterLocal(CpuRegister.A)
-                    asmgen.out("  ldy  #${stringVal.value.length}")
-                    asmgen.out("  jsr  prog8_lib.containment_bytearray")
-                    return
+    private fun containmentCheckIntoA(containment: PtContainmentCheck) {
+        val elementDt = containment.element.type
+        val symbol = asmgen.symbolTable.lookup(containment.iterable.name)
+        val variable = symbol!!.astNode as IPtVariable
+        val varname = asmgen.asmVariableName(containment.iterable)
+        val numElements = when(variable) {
+            is PtConstant -> null
+            is PtMemMapped -> variable.arraySize
+            is PtVariable -> variable.arraySize
         }
-                DataType.ARRAY_F -> {
-                    // require(elementDt istype DataType.FLOAT)
-                    throw AssemblyError("containment check of floats not supported")
-                }
-                in ArrayDatatypes -> {
-                    require(elementDt.isInteger) { "must be integer array ${variable.position}" }
-                    val arrayVal = variable.value as ArrayLiteral
-                    val dt = elementDt.getOr(DataType.UNDEFINED)
-                    val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
-                    when(dt) {
-                        in ByteDatatypes -> {
-                            assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                            asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
-                            assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                            asmgen.restoreRegisterLocal(CpuRegister.A)
-                            asmgen.out("  ldy  #${arrayVal.value.size}")
-                            asmgen.out("  jsr  prog8_lib.containment_bytearray")
-                        }
-                        in WordDatatypes -> {
-                            assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
-                            assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
-                            asmgen.out("  ldy  #${arrayVal.value.size}")
-                            asmgen.out("  jsr  prog8_lib.containment_wordarray")
-                        }
-                        else -> throw AssemblyError("invalid dt")
-                    }
-                    return
-                }
-                else -> throw AssemblyError("invalid dt")
-            }
-        }
-        val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
-        when(variable.datatype) {
+        when(variable.type) {
             DataType.STR -> {
                 // use subroutine
-                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
-                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt == DataType.BYTE)
+                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingISub()!!)
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingISub(), "P8ZP_SCRATCH_W1"), varname)
                 asmgen.restoreRegisterLocal(CpuRegister.A)
-                val stringVal = variable.value as StringLiteral
+                val stringVal = (variable as PtVariable).value as PtString
                 asmgen.out("  ldy  #${stringVal.value.length}")
                 asmgen.out("  jsr  prog8_lib.containment_bytearray")
                 return
@@ -874,19 +831,17 @@ internal class AssignmentAsmGen(private val program: Program,
                 throw AssemblyError("containment check of floats not supported")
             }
             DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                val numElements = variable.arraysize!!.constIndex()!!
-                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
-                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt == DataType.BYTE)
+                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingISub()!!)
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingISub(), "P8ZP_SCRATCH_W1"), varname)
                 asmgen.restoreRegisterLocal(CpuRegister.A)
                 asmgen.out("  ldy  #$numElements")
                 asmgen.out("  jsr  prog8_lib.containment_bytearray")
                 return
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                val numElements = variable.arraysize!!.constIndex()!!
-                assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
-                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
+                assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt, containment.definingISub())
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UWORD, containment.definingISub(), "P8ZP_SCRATCH_W2"), varname)
                 asmgen.out("  ldy  #$numElements")
                 asmgen.out("  jsr  prog8_lib.containment_wordarray")
                 return
@@ -913,14 +868,13 @@ internal class AssignmentAsmGen(private val program: Program,
         assignRegisterByte(target, CpuRegister.A)
     }
 
-    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: Expression, origTypeCastExpression: TypecastExpression) {
-        val valueIDt = value.inferType(program)
-        val valueDt = valueIDt.getOrElse { throw AssemblyError("unknown dt") }
+    private fun assignTypeCastedValue(target: AsmAssignTarget, targetDt: DataType, value: PtExpression, origTypeCastExpression: PtTypeCast) {
+        val valueDt = value.type
         if(valueDt==targetDt)
             throw AssemblyError("type cast to identical dt should have been removed")
 
         when(value) {
-            is IdentifierReference -> {
+            is PtIdentifier -> {
                 if(targetDt in WordDatatypes) {
                     if(valueDt==DataType.UBYTE) {
                         assignVariableUByteIntoWord(target, value)
@@ -932,47 +886,47 @@ internal class AssignmentAsmGen(private val program: Program,
                     }
                 }
             }
-            is DirectMemoryRead -> {
+            is PtMemoryByte -> {
                 if(targetDt in WordDatatypes) {
 
-                    fun assignViaExprEval(addressExpression: Expression) {
+                    fun assignViaExprEval(addressExpression: PtExpression) {
                         asmgen.assignExpressionToVariable(addressExpression, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
                         asmgen.loadAFromZpPointerVar("P8ZP_SCRATCH_W2")
                         asmgen.out("  ldy  #0")
                         assignRegisterpairWord(target, RegisterOrPair.AY)
                     }
 
-                    when (value.addressExpression) {
-                        is NumericLiteral -> {
-                            val address = (value.addressExpression as NumericLiteral).number.toUInt()
+                    when (value.address) {
+                        is PtNumber -> {
+                            val address = (value.address as PtNumber).number.toUInt()
                             assignMemoryByteIntoWord(target, address, null)
                         }
-                        is IdentifierReference -> {
-                            assignMemoryByteIntoWord(target, null, value.addressExpression as IdentifierReference)
+                        is PtIdentifier -> {
+                            assignMemoryByteIntoWord(target, null, value.address as PtIdentifier)
                         }
-                        is BinaryExpression -> {
-                            if(asmgen.tryOptimizedPointerAccessWithA(value.addressExpression as BinaryExpression, false)) {
+                        is PtBinaryExpression -> {
+                            if(asmgen.tryOptimizedPointerAccessWithA(value.address as PtBinaryExpression, false)) {
                                 asmgen.out("  ldy  #0")
                                 assignRegisterpairWord(target, RegisterOrPair.AY)
                             } else {
-                                assignViaExprEval(value.addressExpression)
+                                assignViaExprEval(value.address)
                             }
                         }
                         else -> {
-                            assignViaExprEval(value.addressExpression)
+                            assignViaExprEval(value.address)
                         }
                     }
                     return
                 }
             }
-            is NumericLiteral -> throw AssemblyError("a cast of a literal value should have been const-folded away")
+            is PtNumber -> throw AssemblyError("a cast of a literal value should have been const-folded away")
             else -> {}
         }
 
 
         // special case optimizations
         if(target.kind == TargetStorageKind.VARIABLE) {
-            if(value is IdentifierReference && valueDt != DataType.UNDEFINED)
+            if(value is PtIdentifier && valueDt != DataType.UNDEFINED)
                 return assignTypeCastedIdentifier(target.asmVarname, targetDt, asmgen.asmVariableName(value), valueDt)
 
             when (valueDt) {
@@ -998,7 +952,7 @@ internal class AssignmentAsmGen(private val program: Program,
         }
 
         if(valueDt in WordDatatypes && origTypeCastExpression.type == DataType.UBYTE) {
-            val parentTc = origTypeCastExpression.parent as? TypecastExpression
+            val parentTc = origTypeCastExpression.parent as? PtTypeCast
             if(parentTc!=null && parentTc.type==DataType.UWORD) {
                 // typecast a word value to ubyte and directly back to uword
                 // generate code for lsb(value) here instead of the ubyte typecast
@@ -1111,25 +1065,25 @@ internal class AssignmentAsmGen(private val program: Program,
             when(valueDt) {
                 DataType.UBYTE -> {
                     assignExpressionToRegister(value, RegisterOrPair.Y, false)
-                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingISub()!!)
                     asmgen.out("  jsr  floats.FREADUY")
                     asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
                 DataType.BYTE -> {
                     assignExpressionToRegister(value, RegisterOrPair.A, true)
-                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingISub()!!)
                     asmgen.out("  jsr  floats.FREADSA")
                     asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
                 DataType.UWORD -> {
                     assignExpressionToRegister(value, RegisterOrPair.AY, false)
-                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingISub()!!)
                     asmgen.out("  jsr  floats.GIVUAYFAY")
                     asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
                 DataType.WORD -> {
                     assignExpressionToRegister(value, RegisterOrPair.AY, true)
-                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingSubroutine!!)
+                    asmgen.saveRegisterLocal(CpuRegister.X, origTypeCastExpression.definingISub()!!)
                     asmgen.out("  jsr  floats.GIVAYFAY")
                     asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
@@ -1147,9 +1101,10 @@ internal class AssignmentAsmGen(private val program: Program,
         asmgen.assignExpressionTo(origTypeCastExpression, target)
     }
 
-    private fun assignCastViaLsbFunc(value: Expression, target: AsmAssignTarget) {
-        val lsb = BuiltinFunctionCall(IdentifierReference(listOf("lsb"), value.position), mutableListOf(value), value.position)
-        lsb.linkParents(value.parent)
+    private fun assignCastViaLsbFunc(value: PtExpression, target: AsmAssignTarget) {
+        val lsb = PtBuiltinFunctionCall("lsb", false, true, DataType.UBYTE, value.position)
+        lsb.parent = value.parent
+        lsb.add(value)
         val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UBYTE, expression = lsb)
         val assign = AsmAssignment(src, target, false, program.memsizer, value.position)
         translateNormalAssignment(assign)
@@ -1175,7 +1130,7 @@ internal class AssignmentAsmGen(private val program: Program,
         if(sourceDt == targetDt)
             throw AssemblyError("typecast to identical type")
 
-        // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
+        // also see: PtExpressionAsmGen,   fun translateExpression(typecast: PtTypeCast)
         when(sourceDt) {
             DataType.UBYTE -> {
                 when(targetDt) {
@@ -1290,7 +1245,7 @@ internal class AssignmentAsmGen(private val program: Program,
         if(sourceDt == targetDt)
             throw AssemblyError("typecast to identical type")
 
-        // also see: ExpressionAsmGen,   fun translateExpression(typecast: TypecastExpression)
+        // also see: PtExpressionAsmGen,   fun translateExpression(typecast: PtTypeCast)
         when(sourceDt) {
             DataType.UBYTE -> {
                 when(targetDt) {
@@ -1793,11 +1748,11 @@ internal class AssignmentAsmGen(private val program: Program,
                     ldy  #>${target.asmVarname}
                     sta  P8ZP_SCRATCH_W1
                     sty  P8ZP_SCRATCH_W1+1""")
-                val constIndex = target.array!!.indexer.constIndex()
+                val constIndex = target.array!!.index.asConstInteger()
                 if(constIndex!=null) {
                     asmgen.out(" lda  #$constIndex")
                 } else {
-                    val asmvarname = asmgen.asmVariableName(target.array.indexer.indexExpr as IdentifierReference)
+                    val asmvarname = asmgen.asmVariableName(target.array.index as PtIdentifier)
                     asmgen.out(" lda  $asmvarname")
                 }
                 asmgen.out("  jsr  floats.set_array_float_from_fac1")
@@ -1829,11 +1784,11 @@ internal class AssignmentAsmGen(private val program: Program,
                     ldy  #>${target.asmVarname}
                     sta  P8ZP_SCRATCH_W2
                     sty  P8ZP_SCRATCH_W2+1""")
-                val constIndex = target.array!!.indexer.constIndex()
+                val constIndex = target.array!!.index.asConstInteger()
                 if(constIndex!=null) {
                     asmgen.out(" lda  #$constIndex")
                 } else {
-                    val asmvarname = asmgen.asmVariableName(target.array.indexer.indexExpr as IdentifierReference)
+                    val asmvarname = asmgen.asmVariableName(target.array.index as PtIdentifier)
                     asmgen.out(" lda  $asmvarname")
                 }
                 asmgen.out(" jsr  floats.set_array_float")
@@ -1872,11 +1827,11 @@ internal class AssignmentAsmGen(private val program: Program,
                     ldy  #>${target.asmVarname}
                     sta  P8ZP_SCRATCH_W2
                     sty  P8ZP_SCRATCH_W2+1""")
-                val constIndex = target.array!!.indexer.constIndex()
+                val constIndex = target.array!!.index.asConstInteger()
                 if(constIndex!=null) {
                     asmgen.out(" lda  #$constIndex")
                 } else {
-                    val asmvarname = asmgen.asmVariableName(target.array.indexer.indexExpr as IdentifierReference)
+                    val asmvarname = asmgen.asmVariableName(target.array.index as PtIdentifier)
                     asmgen.out(" lda  $asmvarname")
                 }
                 asmgen.out(" jsr  floats.set_array_float")
@@ -1906,14 +1861,14 @@ internal class AssignmentAsmGen(private val program: Program,
                 storeRegisterAInMemoryAddress(target.memory!!)
             }
             TargetStorageKind.ARRAY -> {
-                if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                if(target.origAstTarget?.array?.variable?.type==DataType.UWORD) {
                     // assigning an indexed pointer var
                     if (target.constArrayIndexValue==0u) {
                         asmgen.out("  lda  $sourceName")
-                        asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                        asmgen.storeAIntoPointerVar(target.origAstTarget.array!!.variable)
                     } else {
                         asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
-                        if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                        if (asmgen.isZpVar(target.origAstTarget.array!!.variable)) {
                             asmgen.out("  lda  $sourceName |  sta  (${target.asmVarname}),y")
                         } else {
                             asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
@@ -1961,7 +1916,7 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun assignVariableByteIntoWord(wordtarget: AsmAssignTarget, bytevar: IdentifierReference) {
+    private fun assignVariableByteIntoWord(wordtarget: AsmAssignTarget, bytevar: PtIdentifier) {
         val sourceName = asmgen.asmVariableName(bytevar)
         when (wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -2042,7 +1997,7 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun assignVariableUByteIntoWord(wordtarget: AsmAssignTarget, bytevar: IdentifierReference) {
+    private fun assignVariableUByteIntoWord(wordtarget: AsmAssignTarget, bytevar: PtIdentifier) {
         val sourceName = asmgen.asmVariableName(bytevar)
         when(wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -2129,7 +2084,7 @@ internal class AssignmentAsmGen(private val program: Program,
                         CpuRegister.X -> asmgen.out(" txa")
                         CpuRegister.Y -> asmgen.out(" tya")
                     }
-                    val indexVar = target.array!!.indexer.indexExpr as IdentifierReference
+                    val indexVar = target.array!!.index as PtIdentifier
                     asmgen.out(" ldy  ${asmgen.asmVariableName(indexVar)} |  sta  ${target.asmVarname},y")
                 }
             }
@@ -2448,14 +2403,14 @@ internal class AssignmentAsmGen(private val program: Program,
                     storeRegisterAInMemoryAddress(target.memory!!)
                 }
                 TargetStorageKind.ARRAY -> {
-                    if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                    if(target.origAstTarget?.array?.variable?.type==DataType.UWORD) {
                         // assigning an indexed pointer var
                         if (target.constArrayIndexValue==0u) {
                             asmgen.out("  lda  #0")
-                            asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                            asmgen.storeAIntoPointerVar(target.origAstTarget.array!!.variable)
                         } else {
                             asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
-                            if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                            if (asmgen.isZpVar(target.origAstTarget.array!!.variable)) {
                                 asmgen.out("  lda  #0 |  sta  (${target.asmVarname}),y")
                             } else {
                                 asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
@@ -2504,14 +2459,14 @@ internal class AssignmentAsmGen(private val program: Program,
                 storeRegisterAInMemoryAddress(target.memory!!)
             }
             TargetStorageKind.ARRAY -> {
-                if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                if(target.origAstTarget?.array?.variable?.type==DataType.UWORD) {
                     // assigning an indexed pointer var
                     if (target.constArrayIndexValue==0u) {
                         asmgen.out("  lda  #${byte.toHex()}")
-                        asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                        asmgen.storeAIntoPointerVar(target.origAstTarget.array!!.variable)
                     } else {
                         asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
-                        if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                        if (asmgen.isZpVar(target.origAstTarget.array!!.variable)) {
                             asmgen.out("  lda  #${byte.toHex()} |  sta  (${target.asmVarname}),y")
                         } else {
                             asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
@@ -2585,7 +2540,7 @@ internal class AssignmentAsmGen(private val program: Program,
                         """)
                 }
                 TargetStorageKind.ARRAY -> {
-                    val constIndex = target.array!!.indexer.constIndex()
+                    val constIndex = target.array!!.index.asConstInteger()
                     if (constIndex!=null) {
                         val indexValue = constIndex * program.memsizer.memorySize(DataType.FLOAT)
                         if(asmgen.isTargetCpu(CpuType.CPU65c02))
@@ -2606,7 +2561,7 @@ internal class AssignmentAsmGen(private val program: Program,
                                 sta  ${target.asmVarname}+$indexValue+4
                             """)
                     } else {
-                        val asmvarname = asmgen.asmVariableName(target.array.indexer.indexExpr as IdentifierReference)
+                        val asmvarname = asmgen.asmVariableName(target.array.index as PtIdentifier)
                         asmgen.out("""
                             lda  #<${target.asmVarname}
                             sta  P8ZP_SCRATCH_W1
@@ -2647,7 +2602,7 @@ internal class AssignmentAsmGen(private val program: Program,
                 }
                 TargetStorageKind.ARRAY -> {
                     val arrayVarName = target.asmVarname
-                    val constIndex = target.array!!.indexer.constIndex()
+                    val constIndex = target.array!!.index.asConstInteger()
                     if (constIndex!=null) {
                         val indexValue = constIndex * program.memsizer.memorySize(DataType.FLOAT)
                         asmgen.out("""
@@ -2659,7 +2614,7 @@ internal class AssignmentAsmGen(private val program: Program,
                             ldy  #>($arrayVarName+$indexValue)
                             jsr  floats.copy_float""")
                     } else {
-                        val asmvarname = asmgen.asmVariableName(target.array.indexer.indexExpr as IdentifierReference)
+                        val asmvarname = asmgen.asmVariableName(target.array.index as PtIdentifier)
                         asmgen.out("""
                             lda  #<${constFloat}
                             sta  P8ZP_SCRATCH_W1
@@ -2691,7 +2646,7 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun assignMemoryByte(target: AsmAssignTarget, address: UInt?, identifier: IdentifierReference?) {
+    private fun assignMemoryByte(target: AsmAssignTarget, address: UInt?, identifier: PtIdentifier?) {
         if (address != null) {
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -2775,7 +2730,7 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun assignMemoryByteIntoWord(wordtarget: AsmAssignTarget, address: UInt?, identifier: IdentifierReference?) {
+    private fun assignMemoryByteIntoWord(wordtarget: AsmAssignTarget, address: UInt?, identifier: PtIdentifier?) {
         if (address != null) {
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -2838,13 +2793,13 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun storeRegisterAInMemoryAddress(memoryAddress: DirectMemoryWrite) {
-        val addressExpr = memoryAddress.addressExpression
-        val addressLv = addressExpr as? NumericLiteral
+    private fun storeRegisterAInMemoryAddress(memoryAddress: PtMemoryByte) {
+        val addressExpr = memoryAddress.address
+        val addressLv = addressExpr as? PtNumber
 
         fun storeViaExprEval() {
             when(addressExpr) {
-                is NumericLiteral, is IdentifierReference -> {
+                is PtNumber, is PtIdentifier -> {
                     assignExpressionToVariable(addressExpr, "P8ZP_SCRATCH_W2", DataType.UWORD, null)
                     asmgen.storeAIntoZpPointerVar("P8ZP_SCRATCH_W2")
                 }
@@ -2862,10 +2817,10 @@ internal class AssignmentAsmGen(private val program: Program,
             addressLv != null -> {
                 asmgen.out("  sta  ${addressLv.number.toHex()}")
             }
-            addressExpr is IdentifierReference -> {
+            addressExpr is PtIdentifier -> {
                 asmgen.storeAIntoPointerVar(addressExpr)
             }
-            addressExpr is BinaryExpression -> {
+            addressExpr is PtBinaryExpression -> {
                 if(!asmgen.tryOptimizedPointerAccessWithA(addressExpr, true))
                     storeViaExprEval()
             }
@@ -2873,15 +2828,15 @@ internal class AssignmentAsmGen(private val program: Program,
         }
     }
 
-    internal fun assignExpressionToRegister(expr: Expression, register: RegisterOrPair, signed: Boolean) {
+    internal fun assignExpressionToRegister(expr: PtExpression, register: RegisterOrPair, signed: Boolean) {
         val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
         val tgt = AsmAssignTarget.fromRegisters(register, signed, null, asmgen)
         val assign = AsmAssignment(src, tgt, false, program.memsizer, expr.position)
         translateNormalAssignment(assign)
     }
 
-    internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) {
-        if(expr.inferType(program) istype DataType.FLOAT && dt!=DataType.FLOAT) {
+    internal fun assignExpressionToVariable(expr: PtExpression, asmVarName: String, dt: DataType, scope: IPtSubroutine?) {
+        if(expr.type==DataType.FLOAT && dt!=DataType.FLOAT) {
             throw AssemblyError("can't directly assign a FLOAT expression to an integer variable $expr")
         } else {
             val src = AsmAssignSource.fromAstSource(expr, program, asmgen)

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

@@ -1,17 +1,14 @@
 package prog8.codegen.cpu6502.assignment
 
-import prog8.ast.Program
-import prog8.ast.base.FatalAstException
-import prog8.ast.expressions.*
-import prog8.ast.statements.Subroutine
+import prog8.code.ast.*
 import prog8.code.core.*
-import prog8.codegen.cpu6502.AsmGen
+import prog8.codegen.cpu6502.AsmGen6502Internal
 import prog8.codegen.cpu6502.VariableAllocator
 
 
-internal class AugmentableAssignmentAsmGen(private val program: Program,
+internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                            private val assignmentAsmGen: AssignmentAsmGen,
-                                           private val asmgen: AsmGen,
+                                           private val asmgen: AsmGen6502Internal,
                                            private val allocator: VariableAllocator
 ) {
     fun translate(assign: AsmAssignment) {
@@ -21,7 +18,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
 
         when (val value = assign.source.expression!!) {
-            is PrefixExpression -> {
+            is PtPrefix -> {
                 // A = -A , A = +A, A = ~A, A = not A
                 when (value.operator) {
                     "+" -> {}
@@ -30,13 +27,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     else -> throw AssemblyError("invalid prefix operator")
                 }
             }
-            is TypecastExpression -> inplaceCast(assign.target, value, assign.position)
-            is BinaryExpression -> inplaceBinary(assign.target, value)
+            is PtTypeCast -> inplaceCast(assign.target, value, assign.position)
+            is PtBinaryExpression -> inplaceBinary(assign.target, value)
             else -> throw AssemblyError("invalid aug assign value type")
         }
     }
 
-    private fun inplaceBinary(target: AsmAssignTarget, binExpr: BinaryExpression) {
+    private fun inplaceBinary(target: AsmAssignTarget, binExpr: PtBinaryExpression) {
         val astTarget = target.origAstTarget!!
         if (binExpr.left isSameAs astTarget) {
             // A = A <operator> Something
@@ -49,7 +46,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 return inplaceModification(target, binExpr.operator, binExpr.left)
             }
 
-            val leftBinExpr = binExpr.left as? BinaryExpression
+            val leftBinExpr = binExpr.left as? PtBinaryExpression
             if (leftBinExpr?.operator == binExpr.operator) {
                 // TODO better optimize the chained asm to avoid intermediate stores/loads?
                 when {
@@ -73,7 +70,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                 }
             }
-            val rightBinExpr = binExpr.right as? BinaryExpression
+            val rightBinExpr = binExpr.right as? PtBinaryExpression
             if (rightBinExpr?.operator == binExpr.operator) {
                 when {
                     binExpr.left isSameAs astTarget -> {
@@ -98,8 +95,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
         }
 
-        val leftBinExpr = binExpr.left as? BinaryExpression
-        val rightBinExpr = binExpr.right as? BinaryExpression
+        val leftBinExpr = binExpr.left as? PtBinaryExpression
+        val rightBinExpr = binExpr.right as? PtBinaryExpression
         if(leftBinExpr!=null && rightBinExpr==null) {
             if(leftBinExpr.left isSameAs astTarget) {
                 // X = (X <oper> Right) <oper> Something
@@ -141,26 +138,27 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
         }
 
-        throw FatalAstException("assignment should follow augmentable rules $binExpr")
+        throw AssemblyError("assignment should follow augmentable rules $binExpr")
     }
 
-    private fun inplaceModification(target: AsmAssignTarget, operator: String, origValue: Expression) {
+    private fun inplaceModification(target: AsmAssignTarget, operator: String, origValue: PtExpression) {
 
         // the asm-gen code can deal with situations where you want to assign a byte into a word.
         // it will create the most optimized code to do this (so it type-extends for us).
         // But we can't deal with writing a word into a byte - explicit typeconversion is required
-        val value = if(program.memsizer.memorySize(origValue.inferType(program).getOrElse { throw AssemblyError("unknown dt") }) > program.memsizer.memorySize(target.datatype)) {
-            val typecast = TypecastExpression(origValue, target.datatype, true, origValue.position)
-            typecast.linkParents(origValue.parent)
+        val value = if(program.memsizer.memorySize(origValue.type) > program.memsizer.memorySize(target.datatype)) {
+            val typecast = PtTypeCast(target.datatype, origValue.position)
+            typecast.add(origValue)
+            require(typecast.type!=origValue.type)
             typecast
         }
         else {
             origValue
         }
 
-        val valueLv = (value as? NumericLiteral)?.number
-        val ident = value as? IdentifierReference
-        val memread = value as? DirectMemoryRead
+        val valueLv = (value as? PtNumber)?.number
+        val ident = value as? PtIdentifier
+        val memread = value as? PtMemoryByte
 
         when (target.kind) {
             TargetStorageKind.VARIABLE -> {
@@ -170,7 +168,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             valueLv != null -> inplaceModification_byte_litval_to_variable(target.asmVarname, target.datatype, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable(target.asmVarname, target.datatype, operator, ident)
                             memread != null -> inplaceModification_byte_memread_to_variable(target.asmVarname, target.datatype, operator, memread)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_variable(target.asmVarname, target.datatype, operator, value)
                             }
@@ -182,7 +180,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                             valueLv != null -> inplaceModification_word_litval_to_variable(target.asmVarname, target.datatype, operator, valueLv.toInt())
                             ident != null -> inplaceModification_word_variable_to_variable(target.asmVarname, target.datatype, operator, ident)
                             memread != null -> inplaceModification_word_memread_to_variable(target.asmVarname, target.datatype, operator, memread)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator))
                                     return
                                 inplaceModification_word_value_to_variable(target.asmVarname, target.datatype, operator, value)
@@ -194,7 +192,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         when {
                             valueLv != null -> inplaceModification_float_litval_to_variable(target.asmVarname, operator, valueLv.toDouble(), target.scope!!)
                             ident != null -> inplaceModification_float_variable_to_variable(target.asmVarname, operator, ident, target.scope!!)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                 inplaceModification_float_value_to_variable(target.asmVarname, operator, value, target.scope!!)
                             }
@@ -206,27 +204,27 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             TargetStorageKind.MEMORY -> {
                 val memory = target.memory!!
-                when (memory.addressExpression) {
-                    is NumericLiteral -> {
-                        val addr = (memory.addressExpression as NumericLiteral).number.toInt()
+                when (memory.address) {
+                    is PtNumber -> {
+                        val addr = (memory.address as PtNumber).number.toInt()
                         // re-use code to assign a variable, instead this time, use a direct memory address
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_variable(addr.toHex(), DataType.UBYTE, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable(addr.toHex(), DataType.UBYTE, operator, ident)
                             memread != null -> inplaceModification_byte_memread_to_variable(addr.toHex(), DataType.UBYTE, operator, value)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_variable(addr.toHex(), DataType.UBYTE, operator, value)
                             }
                             else -> inplaceModification_byte_value_to_variable(addr.toHex(), DataType.UBYTE, operator, value)
                         }
                     }
-                    is IdentifierReference -> {
-                        val pointer = memory.addressExpression as IdentifierReference
+                    is PtIdentifier -> {
+                        val pointer = memory.address as PtIdentifier
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_pointer(pointer, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_pointer(pointer, operator, ident)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_pointer(pointer, operator, value)
                             }
@@ -235,13 +233,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     else -> {
                         // TODO use some other evaluation here; don't use the estack to transfer the address to read/write from
-                        asmgen.assignExpressionTo(memory.addressExpression, AsmAssignTarget(TargetStorageKind.STACK, asmgen, DataType.UWORD, memory.definingSubroutine))
+                        asmgen.assignExpressionTo(memory.address, AsmAssignTarget(TargetStorageKind.STACK, asmgen, DataType.UWORD, memory.definingISub()))
                         asmgen.out("  jsr  prog8_lib.read_byte_from_address_on_stack |  sta  P8ZP_SCRATCH_B1")
                         when {
                             valueLv != null -> inplaceModification_byte_litval_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, valueLv.toInt())
                             ident != null -> inplaceModification_byte_variable_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, ident)
                             memread != null -> inplaceModification_byte_memread_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, memread)
-                            value is TypecastExpression -> {
+                            value is PtTypeCast -> {
                                 if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                 inplaceModification_byte_value_to_variable("P8ZP_SCRATCH_B1", DataType.UBYTE, operator, value)
                             }
@@ -252,9 +250,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 }
             }
             TargetStorageKind.ARRAY -> {
-                with(target.array!!.indexer) {
-                    val indexNum = indexExpr as? NumericLiteral
-                    val indexVar = indexExpr as? IdentifierReference
+                val indexNum = target.array!!.index as? PtNumber
+                val indexVar = target.array.index as? PtIdentifier
                 when {
                     indexNum!=null -> {
                         val targetVarName = "${target.asmVarname} + ${indexNum.number.toInt()*program.memsizer.memorySize(target.datatype)}"
@@ -264,7 +261,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                     valueLv != null -> inplaceModification_byte_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
                                     ident != null -> inplaceModification_byte_variable_to_variable(targetVarName, target.datatype, operator, ident)
                                     memread != null -> inplaceModification_byte_memread_to_variable(targetVarName, target.datatype, operator, memread)
-                                        value is TypecastExpression -> {
+                                    value is PtTypeCast -> {
                                         if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                         inplaceModification_byte_value_to_variable(targetVarName, target.datatype, operator, value)
                                     }
@@ -276,7 +273,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                     valueLv != null -> inplaceModification_word_litval_to_variable(targetVarName, target.datatype, operator, valueLv.toInt())
                                     ident != null -> inplaceModification_word_variable_to_variable(targetVarName, target.datatype, operator, ident)
                                     memread != null -> inplaceModification_word_memread_to_variable(targetVarName, target.datatype, operator, memread)
-                                        value is TypecastExpression -> {
+                                    value is PtTypeCast -> {
                                         if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                         inplaceModification_word_value_to_variable(targetVarName, target.datatype, operator, value)
                                     }
@@ -287,7 +284,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                 when {
                                     valueLv != null -> inplaceModification_float_litval_to_variable(targetVarName, operator, valueLv.toDouble(), target.scope!!)
                                     ident != null -> inplaceModification_float_variable_to_variable(targetVarName, operator, ident, target.scope!!)
-                                        value is TypecastExpression -> {
+                                    value is PtTypeCast -> {
                                         if (tryInplaceModifyWithRemovedRedundantCast(value, target, operator)) return
                                         inplaceModification_float_value_to_variable(targetVarName, operator, value, target.scope!!)
                                     }
@@ -338,27 +335,25 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     else -> throw AssemblyError("indexer expression should have been replaced by auto indexer var")
                 }
             }
-            }
             TargetStorageKind.REGISTER -> throw AssemblyError("no asm gen for reg in-place modification")
             TargetStorageKind.STACK -> throw AssemblyError("no asm gen for stack in-place modification")
         }
     }
 
-    private fun tryInplaceModifyWithRemovedRedundantCast(value: TypecastExpression, target: AsmAssignTarget, operator: String): Boolean {
+    private fun tryInplaceModifyWithRemovedRedundantCast(value: PtTypeCast, target: AsmAssignTarget, operator: String): Boolean {
         if (target.datatype == value.type) {
-            val childIDt = value.expression.inferType(program)
-            val childDt = childIDt.getOrElse { throw AssemblyError("unknown dt") }
+            val childDt = value.value.type
             if (value.type!=DataType.FLOAT && (value.type.equalsSize(childDt) || value.type.largerThan(childDt))) {
                 // this typecast is redundant here; the rest of the code knows how to deal with the uncasted value.
                 // (works for integer types, not for float.)
-                inplaceModification(target, operator, value.expression)
+                inplaceModification(target, operator, value.value)
                 return true
             }
         }
         return false
     }
 
-    private fun inplaceModification_byte_value_to_pointer(pointervar: IdentifierReference, operator: String, value: Expression) {
+    private fun inplaceModification_byte_value_to_pointer(pointervar: PtIdentifier, operator: String, value: PtExpression) {
         asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_B1", DataType.UBYTE, null)
         val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
         when (operator) {
@@ -394,7 +389,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.storeAIntoZpPointerVar(sourceName)
     }
 
-    private fun inplaceModification_byte_variable_to_pointer(pointervar: IdentifierReference, operator: String, value: IdentifierReference) {
+    private fun inplaceModification_byte_variable_to_pointer(pointervar: PtIdentifier, operator: String, value: PtIdentifier) {
         val otherName = asmgen.asmVariableName(value)
         val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
 
@@ -431,7 +426,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.storeAIntoZpPointerVar(sourceName)
     }
 
-    private fun inplaceModification_byte_litval_to_pointer(pointervar: IdentifierReference, operator: String, value: Int) {
+    private fun inplaceModification_byte_litval_to_pointer(pointervar: PtIdentifier, operator: String, value: Int) {
         when (operator) {
             // note: ** (power) operator requires floats.
             "+" -> {
@@ -499,7 +494,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_byte_value_to_variable(name: String, dt: DataType, operator: String, value: Expression) {
+    private fun inplaceModification_byte_value_to_variable(name: String, dt: DataType, operator: String, value: PtExpression) {
         // this should be the last resort for code generation for this,
         // because the value is evaluated onto the eval stack (=slow).
         when (operator) {
@@ -594,7 +589,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_byte_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) {
+    private fun inplaceModification_byte_variable_to_variable(name: String, dt: DataType, operator: String, ident: PtIdentifier) {
         val otherName = asmgen.asmVariableName(ident)
         when (operator) {
             // note: ** (power) operator requires floats.
@@ -762,7 +757,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_byte_memread_to_variable(name: String, dt: DataType, operator: String, memread: DirectMemoryRead) {
+    private fun inplaceModification_byte_memread_to_variable(name: String, dt: DataType, operator: String, memread: PtMemoryByte) {
         when (operator) {
             "+" -> {
                 asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
@@ -799,7 +794,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_word_memread_to_variable(name: String, dt: DataType, operator: String, memread: DirectMemoryRead) {
+    private fun inplaceModification_word_memread_to_variable(name: String, dt: DataType, operator: String, memread: PtMemoryByte) {
         when (operator) {
             "+" -> {
                 asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
@@ -1111,9 +1106,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_word_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) {
+    private fun inplaceModification_word_variable_to_variable(name: String, dt: DataType, operator: String, ident: PtIdentifier) {
         val otherName = asmgen.asmVariableName(ident)
-        when (val valueDt = ident.targetVarDecl(program)!!.datatype) {
+        when (val valueDt = ident.type) {
             in ByteDatatypes -> {
                 // the other variable is a BYTE type so optimize for that
                 when (operator) {
@@ -1356,12 +1351,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_word_value_to_variable(name: String, dt: DataType, operator: String, value: Expression) {
+    private fun inplaceModification_word_value_to_variable(name: String, dt: DataType, operator: String, value: PtExpression) {
         // this should be the last resort for code generation for this,
         // because the value is evaluated onto the eval stack (=slow).
 
-        val valueiDt = value.inferType(program)
-        val valueDt = valueiDt.getOrElse { throw AssemblyError("unknown dt") }
 
         fun multiplyVarByWordInAY() {
             asmgen.out("""
@@ -1410,7 +1403,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             """)
         }
 
-        when (valueDt) {
+        when (val valueDt = value.type) {
             in ByteDatatypes -> {
                 // the other variable is a BYTE type so optimize for that
                 when (operator) {
@@ -1581,7 +1574,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         }
     }
 
-    private fun inplaceModification_float_value_to_variable(name: String, operator: String, value: Expression, scope: Subroutine) {
+    private fun inplaceModification_float_value_to_variable(name: String, operator: String, value: PtExpression, scope: IPtSubroutine) {
         asmgen.assignExpressionToRegister(value, RegisterOrPair.FAC1)
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
@@ -1623,8 +1616,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
-    private fun inplaceModification_float_variable_to_variable(name: String, operator: String, ident: IdentifierReference, scope: Subroutine) {
-        val valueDt = ident.targetVarDecl(program)!!.datatype
+    private fun inplaceModification_float_variable_to_variable(name: String, operator: String, ident: PtIdentifier, scope: IPtSubroutine) {
+        val valueDt = ident.type
         if(valueDt != DataType.FLOAT)
             throw AssemblyError("float variable expected")
 
@@ -1682,7 +1675,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
-    private fun inplaceModification_float_litval_to_variable(name: String, operator: String, value: Double, scope: Subroutine) {
+    private fun inplaceModification_float_litval_to_variable(name: String, operator: String, value: Double, scope: IPtSubroutine) {
         val constValueName = allocator.getFloatAsmConst(value)
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
@@ -1744,9 +1737,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.restoreRegisterLocal(CpuRegister.X)
     }
 
-    private fun inplaceCast(target: AsmAssignTarget, cast: TypecastExpression, position: Position) {
+    private fun inplaceCast(target: AsmAssignTarget, cast: PtTypeCast, position: Position) {
         val outerCastDt = cast.type
-        val innerCastDt = (cast.expression as? TypecastExpression)?.type
+        val innerCastDt = (cast.value as? PtTypeCast)?.type
         if (innerCastDt == null) {
             // simple typecast where the value is the target
             when (target.datatype) {
@@ -1789,8 +1782,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             // typecast with nested typecast, that has the target as a value
             // calculate singular cast that is required
             val castDt = if (outerCastDt largerThan innerCastDt) innerCastDt else outerCastDt
-            val value = (cast.expression as TypecastExpression).expression
-            val resultingCast = TypecastExpression(value, castDt, false, position)
+            val resultingCast = PtTypeCast(castDt, position)
+            resultingCast.add((cast.value as PtTypeCast).value)
+            require(castDt!=resultingCast.value.type)
             inplaceCast(target, resultingCast, position)
         }
     }
@@ -1808,21 +1802,21 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     TargetStorageKind.MEMORY -> {
                         val memory = target.memory!!
-                        when (memory.addressExpression) {
-                            is NumericLiteral -> {
-                                val addr = (memory.addressExpression as NumericLiteral).number.toHex()
+                        when (memory.address) {
+                            is PtNumber -> {
+                                val addr = (memory.address as PtNumber).number.toHex()
                                 asmgen.out("""
                                     lda  $addr
                                     eor  #255
                                     sta  $addr""")
                             }
-                            is IdentifierReference -> {
-                                val sourceName = asmgen.loadByteFromPointerIntoA(memory.addressExpression as IdentifierReference)
+                            is PtIdentifier -> {
+                                val sourceName = asmgen.loadByteFromPointerIntoA(memory.address as PtIdentifier)
                                 asmgen.out("  eor  #255")
                                 asmgen.out("  sta  ($sourceName),y")
                             }
                             else -> {
-                                asmgen.assignExpressionToVariable(memory.addressExpression, "P8ZP_SCRATCH_W2", DataType.UWORD, target.scope)
+                                asmgen.assignExpressionToVariable(memory.address, "P8ZP_SCRATCH_W2", DataType.UWORD, target.scope)
                                 asmgen.out("""
                                     ldy  #0
                                     lda  (P8ZP_SCRATCH_W2),y

codeGenCpu6502/test/TestCodegen.kt

@@ -0,0 +1,10 @@
+package prog8tests.codegencpu6502
+
+import io.kotest.core.spec.style.FunSpec
+
+class TestCodegen: FunSpec({
+
+    // TODO there are no 6502 specific codegen tests yet
+
+})
+

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

@@ -3,19 +3,19 @@ package prog8.codegen.experimental
 import prog8.code.SymbolTable
 import prog8.code.ast.PtProgram
 import prog8.code.core.CompilationOptions
-import prog8.code.core.IAssemblyGenerator
 import prog8.code.core.IAssemblyProgram
+import prog8.code.core.ICodeGeneratorBackend
 import prog8.code.core.IErrorReporter
 import prog8.codegen.intermediate.IRCodeGen
 import prog8.intermediate.IRFileWriter
 
-class CodeGen(private val program: PtProgram,
-              private val symbolTable: SymbolTable,
-              private val options: CompilationOptions,
-              private val errors: IErrorReporter
-): IAssemblyGenerator {
-    override fun compileToAssembly(): IAssemblyProgram? {
-
+class ExperiCodeGen: ICodeGeneratorBackend {
+    override fun generate(
+        program: PtProgram,
+        symbolTable: SymbolTable,
+        options: CompilationOptions,
+        errors: IErrorReporter
+    ): IAssemblyProgram? {
         // you could write a code generator directly on the PtProgram AST,
         // but you can also use the Intermediate Representation to build a codegen on:
         val irCodeGen = IRCodeGen(program, symbolTable, options, errors)

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

@@ -988,20 +988,20 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                             if(fcall.type==DataType.FLOAT)
                                 throw AssemblyError("doesn't support float register result in asm romsub")
                             val returns = callTarget.returns.single()
-                            val regStr = if(returns.registerOrPair!=null) returns.registerOrPair.toString() else returns.statusflag.toString()
+                            val regStr = if(returns.register.registerOrPair!=null) returns.register.registerOrPair.toString() else returns.register.statusflag.toString()
                             addInstr(result, IRInstruction(Opcode.LOADCPU, codeGen.irType(fcall.type), reg1=resultRegister, labelSymbol = regStr), null)
                         }
                         else -> {
-                            val returnRegister = callTarget.returns.singleOrNull{ it.registerOrPair!=null }
+                            val returnRegister = callTarget.returns.singleOrNull{ it.register.registerOrPair!=null }
                             if(returnRegister!=null) {
                                 // we skip the other values returned in the status flags.
-                                val regStr = returnRegister.registerOrPair.toString()
+                                val regStr = returnRegister.register.registerOrPair.toString()
                                 addInstr(result, IRInstruction(Opcode.LOADCPU, codeGen.irType(fcall.type), reg1=resultRegister, labelSymbol = regStr), null)
                             } else {
-                                val firstReturnRegister = callTarget.returns.firstOrNull{ it.registerOrPair!=null }
+                                val firstReturnRegister = callTarget.returns.firstOrNull{ it.register.registerOrPair!=null }
                                 if(firstReturnRegister!=null) {
                                     // we just take the first register return value and ignore the rest.
-                                    val regStr = firstReturnRegister.registerOrPair.toString()
+                                    val regStr = firstReturnRegister.register.registerOrPair.toString()
                                     addInstr(result, IRInstruction(Opcode.LOADCPU, codeGen.irType(fcall.type), reg1=resultRegister, labelSymbol = regStr), null)
                                 } else {
                                     throw AssemblyError("invalid number of return values from call")

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

@@ -1203,8 +1203,8 @@ class IRCodeGen(
                             child.name,
                             child.address,
                             child.clobbers,
-                            child.parameters.map { IRAsmSubroutine.IRAsmParam(it.second, it.first.type) },        // note: the name of the asmsub param is not used anymore.
-                            child.returnTypes.zip(child.retvalRegisters).map { IRAsmSubroutine.IRAsmParam(it.second, it.first) },
+                            child.parameters.map { IRAsmSubroutine.IRAsmParam(it.first, it.second.type) },        // note: the name of the asmsub param is not used here anymore
+                            child.returns.map { IRAsmSubroutine.IRAsmParam(it.first, it.second)},
                             asmChunk,
                             child.position
                         )

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

@@ -3,23 +3,22 @@ package prog8.codegen.vm
 import prog8.code.SymbolTable
 import prog8.code.ast.PtProgram
 import prog8.code.core.CompilationOptions
-import prog8.code.core.IAssemblyGenerator
 import prog8.code.core.IAssemblyProgram
+import prog8.code.core.ICodeGeneratorBackend
 import prog8.code.core.IErrorReporter
 import prog8.codegen.intermediate.IRCodeGen
 import prog8.intermediate.IRFileWriter
 import prog8.intermediate.IRProgram
 
-class VmCodeGen(private val program: PtProgram,
-                private val symbolTable: SymbolTable,
-                private val options: CompilationOptions,
-                private val errors: IErrorReporter
-): IAssemblyGenerator {
-    override fun compileToAssembly(): IAssemblyProgram? {
-
+class VmCodeGen: ICodeGeneratorBackend {
+    override fun generate(
+        program: PtProgram,
+        symbolTable: SymbolTable,
+        options: CompilationOptions,
+        errors: IErrorReporter
+    ): IAssemblyProgram? {
         val irCodeGen = IRCodeGen(program, symbolTable, options, errors)
         val irProgram = irCodeGen.generate()
-
         return VmAssemblyProgram(irProgram.name, irProgram)
     }
 }

codeGenIntermediate/test/Dummies.kt

@@ -14,7 +14,7 @@ internal object DummyStringEncoder : IStringEncoding {
         return emptyList()
     }
 
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
         return ""
     }
 }

compiler/src/prog8/CompilerMain.kt

@@ -206,13 +206,13 @@ private fun compileMain(args: Array<String>): Boolean {
             }
 
             if(startEmulator1==true || startEmulator2==true) {
-                if (compilationResult.program.name.isEmpty()) {
+                if (compilationResult.compilerAst.name.isEmpty()) {
                     println("\nCan't start emulator because no program was assembled.")
                     return true
                 }
             }
 
-            val programNameInPath = outputPath.resolve(compilationResult.program.name)
+            val programNameInPath = outputPath.resolve(compilationResult.compilerAst.name)
 
             if(startEmulator1==true || startEmulator2==true) {
                 if (compilationResult.compilationOptions.launcher != CbmPrgLauncherType.NONE || compilationTarget=="atari") {

compiler/src/prog8/compiler/BuiltinFunctions.kt

@@ -0,0 +1,158 @@
+package prog8.compiler
+
+import prog8.ast.Program
+import prog8.ast.base.AstException
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.SyntaxError
+import prog8.ast.expressions.*
+import prog8.ast.statements.VarDecl
+import prog8.code.core.*
+import kotlin.math.abs
+import kotlin.math.sign
+import kotlin.math.sqrt
+
+
+private typealias ConstExpressionCaller = (args: List<Expression>, position: Position, program: Program) -> NumericLiteral
+
+internal val constEvaluatorsForBuiltinFuncs: Map<String, ConstExpressionCaller> = mapOf(
+    "abs" to ::builtinAbs,
+    "len" to ::builtinLen,
+    "sizeof" to ::builtinSizeof,
+    "sgn" to ::builtinSgn,
+    "sqrt16" to { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()) } },
+    "any" to { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
+    "all" to { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
+    "lsb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> (x and 255).toDouble() } },
+    "msb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> (x ushr 8 and 255).toDouble()} },
+    "mkword" to ::builtinMkword
+)
+
+private fun builtinAny(array: List<Double>): Double = if(array.any { it!=0.0 }) 1.0 else 0.0
+
+private fun builtinAll(array: List<Double>): Double = if(array.all { it!=0.0 }) 1.0 else 0.0
+
+internal fun builtinFunctionReturnType(function: String): InferredTypes.InferredType {
+    if(function in arrayOf("set_carry", "set_irqd", "clear_carry", "clear_irqd"))
+        return InferredTypes.InferredType.void()
+
+    val func = BuiltinFunctions.getValue(function)
+    val returnType = func.returnType
+    return if(returnType==null)
+        InferredTypes.InferredType.void()
+    else
+        InferredTypes.knownFor(returnType)
+}
+
+
+internal class NotConstArgumentException: AstException("not a const argument to a built-in function")
+internal class CannotEvaluateException(func:String, msg: String): FatalAstException("cannot evaluate built-in function $func: $msg")
+
+
+private fun oneIntArgOutputInt(args: List<Expression>, position: Position, program: Program, function: (arg: Int)->Double): NumericLiteral {
+    if(args.size!=1)
+        throw SyntaxError("built-in function requires one integer argument", position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    if(constval.type != DataType.UBYTE && constval.type!= DataType.UWORD)
+        throw SyntaxError("built-in function requires one integer argument", position)
+
+    val integer = constval.number.toInt()
+    return NumericLiteral.optimalInteger(function(integer).toInt(), args[0].position)
+}
+
+private fun collectionArg(args: List<Expression>, position: Position, program: Program, function: (arg: List<Double>)->Double): NumericLiteral {
+    if(args.size!=1)
+        throw SyntaxError("builtin function requires one non-scalar argument", position)
+
+    val array= args[0] as? ArrayLiteral ?: throw NotConstArgumentException()
+    val constElements = array.value.map{it.constValue(program)?.number}
+    if(constElements.contains(null))
+        throw NotConstArgumentException()
+
+    return NumericLiteral.optimalNumeric(function(constElements.mapNotNull { it }), args[0].position)
+}
+
+private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    // 1 arg, type = int, result type= uword
+    if(args.size!=1)
+        throw SyntaxError("abs requires one integer argument", position)
+
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    return when (constval.type) {
+        in IntegerDatatypesNoBool -> NumericLiteral.optimalInteger(abs(constval.number.toInt()), args[0].position)
+        else -> throw SyntaxError("abs requires one integer argument", position)
+    }
+}
+
+private fun builtinSizeof(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    // 1 arg, type = anything, result type = ubyte
+    if(args.size!=1)
+        throw SyntaxError("sizeof requires one argument", position)
+    if(args[0] !is IdentifierReference)
+        throw SyntaxError("sizeof argument should be an identifier", position)
+
+    val dt = args[0].inferType(program)
+    if(dt.isKnown) {
+        val target = (args[0] as IdentifierReference).targetStatement(program)
+            ?: throw CannotEvaluateException("sizeof", "no target")
+
+        return when {
+            dt.isArray -> {
+                val length = (target as VarDecl).arraysize!!.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
+                val elementDt = ArrayToElementTypes.getValue(dt.getOr(DataType.UNDEFINED))
+                NumericLiteral.optimalInteger(program.memsizer.memorySize(elementDt) * length, position)
+            }
+            dt istype DataType.STR -> throw SyntaxError("sizeof str is undefined, did you mean len?", position)
+            else -> NumericLiteral(DataType.UBYTE, program.memsizer.memorySize(dt.getOr(DataType.UNDEFINED)).toDouble(), position)
+        }
+    } else {
+        throw SyntaxError("sizeof invalid argument type", position)
+    }
+}
+
+private fun builtinLen(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    // note: in some cases the length is > 255, and then we have to return a UWORD type instead of a UBYTE.
+    if(args.size!=1)
+        throw SyntaxError("len requires one argument", position)
+
+    val directMemVar = ((args[0] as? DirectMemoryRead)?.addressExpression as? IdentifierReference)?.targetVarDecl(program)
+    var arraySize = directMemVar?.arraysize?.constIndex()
+    if(arraySize != null)
+        return NumericLiteral.optimalInteger(arraySize, position)
+    if(args[0] is ArrayLiteral)
+        return NumericLiteral.optimalInteger((args[0] as ArrayLiteral).value.size, position)
+    if(args[0] !is IdentifierReference)
+        throw SyntaxError("len argument should be an identifier", position)
+    val target = (args[0] as IdentifierReference).targetVarDecl(program)
+        ?: throw CannotEvaluateException("len", "no target vardecl")
+
+    return when(target.datatype) {
+        in ArrayDatatypes -> {
+            arraySize = target.arraysize?.constIndex()
+            if(arraySize==null)
+                throw CannotEvaluateException("len", "arraysize unknown")
+            NumericLiteral.optimalInteger(arraySize, args[0].position)
+        }
+        DataType.STR -> {
+            val refLv = target.value as? StringLiteral ?: throw CannotEvaluateException("len", "stringsize unknown")
+            NumericLiteral.optimalInteger(refLv.value.length, args[0].position)
+        }
+        in NumericDatatypes -> throw SyntaxError("cannot use len on numeric value, did you mean sizeof?", args[0].position)
+        else -> throw InternalCompilerException("weird datatype")
+    }
+}
+
+private fun builtinMkword(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    if (args.size != 2)
+        throw SyntaxError("mkword requires msb and lsb arguments", position)
+    val constMsb = args[0].constValue(program) ?: throw NotConstArgumentException()
+    val constLsb = args[1].constValue(program) ?: throw NotConstArgumentException()
+    val result = (constMsb.number.toInt() shl 8) or constLsb.number.toInt()
+    return NumericLiteral(DataType.UWORD, result.toDouble(), position)
+}
+
+private fun builtinSgn(args: List<Expression>, position: Position, program: Program): NumericLiteral {
+    if (args.size != 1)
+        throw SyntaxError("sgn requires one argument", position)
+    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
+    return NumericLiteral(DataType.BYTE, constval.number.sign, position)
+}

compiler/src/prog8/compiler/Compiler.kt

@@ -1,17 +1,14 @@
 package prog8.compiler
 
 import com.github.michaelbull.result.onFailure
-import prog8.ast.AstToSourceTextConverter
 import prog8.ast.IBuiltinFunctions
-import prog8.ast.IStatementContainer
 import prog8.ast.Program
 import prog8.ast.base.AstException
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.Directive
-import prog8.ast.statements.VarDecl
-import prog8.ast.walk.IAstVisitor
-import prog8.code.SymbolTable
+import prog8.code.SymbolTableMaker
+import prog8.code.ast.PtProgram
 import prog8.code.core.*
 import prog8.code.target.*
 import prog8.codegen.vm.VmCodeGen
@@ -25,7 +22,8 @@ import kotlin.math.round
 import kotlin.system.measureTimeMillis
 
 
-class CompilationResult(val program: Program,
+class CompilationResult(val compilerAst: Program,   // deprecated, use codegenAst instead
+                        val codegenAst: PtProgram?,
                         val compilationOptions: CompilationOptions,
                         val importedFiles: List<Path>)
 
@@ -63,6 +61,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
         }
 
     var compilationOptions: CompilationOptions
+    var ast: PtProgram? = null
 
     try {
         val totalTime = measureTimeMillis {
@@ -113,10 +112,22 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
             args.errors.report()
 
             if (args.writeAssembly) {
-                if(!createAssemblyAndAssemble(program, args.errors, compilationOptions)) {
+
+                compilationOptions.compTarget.machine.initializeMemoryAreas(compilationOptions)
+                program.processAstBeforeAsmGeneration(compilationOptions, args.errors)
+                args.errors.report()
+
+                val intermediateAst = IntermediateAstMaker(program, compilationOptions).transform()
+//                println("*********** COMPILER AST RIGHT BEFORE ASM GENERATION *************")
+//                printProgram(program)
+//                println("*********** AST RIGHT BEFORE ASM GENERATION *************")
+//                printAst(intermediateAst, ::println)
+
+                if(!createAssemblyAndAssemble(intermediateAst, args.errors, compilationOptions)) {
                     System.err.println("Error in codegeneration or assembler")
                     return null
                 }
+                ast = intermediateAst
             }
         }
 
@@ -124,7 +135,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
         System.err.flush()
         val seconds = totalTime/1000.0
         println("\nTotal compilation+assemble time: ${round(seconds*100.0)/100.0} sec.")
-        return CompilationResult(program, compilationOptions, importedFiles)
+        return CompilationResult(program, ast, compilationOptions, importedFiles)
     } catch (px: ParseError) {
         System.err.print("\n\u001b[91m")  // bright red
         System.err.println("${px.position.toClickableStr()} parse error: ${px.message}".trim())
@@ -208,7 +219,7 @@ private class BuiltinFunctionsFacade(functions: Map<String, FSignature>): IBuilt
     override fun constValue(funcName: String, args: List<Expression>, position: Position): NumericLiteral? {
         val func = BuiltinFunctions[funcName]
         if(func!=null) {
-            val exprfunc = func.constExpressionFunc
+            val exprfunc = constEvaluatorsForBuiltinFuncs[funcName]
             if(exprfunc!=null) {
                 return try {
                     exprfunc(args, position, program)
@@ -385,25 +396,23 @@ private fun postprocessAst(program: Program, errors: IErrorReporter, compilerOpt
     errors.report()
 }
 
-private fun createAssemblyAndAssemble(program: Program,
+private fun createAssemblyAndAssemble(program: PtProgram,
                                       errors: IErrorReporter,
                                       compilerOptions: CompilationOptions
 ): Boolean {
-    compilerOptions.compTarget.machine.initializeMemoryAreas(compilerOptions)
-    program.processAstBeforeAsmGeneration(compilerOptions, errors)
-    errors.report()
-    val symbolTable = SymbolTableMaker(program, compilerOptions).make()
 
-    // TODO make removing all VarDecls work, but this needs inferType to be able to get its information from somewhere else as the VarDecl nodes in the Ast,
-    //      or don't use inferType at all anymore and "bake the type information" into the Ast somehow.
-    //      Note: we don't actually *need* to remove the VarDecl nodes, but it is nice as a temporary measure
-    //      to help clean up the code that still depends on them.
-    // removeAllVardeclsFromAst(program)
+    val asmgen = if(compilerOptions.experimentalCodegen)
+        prog8.codegen.experimental.ExperiCodeGen()
+    else if (compilerOptions.compTarget.machine.cpu in arrayOf(CpuType.CPU6502, CpuType.CPU65c02))
+        prog8.codegen.cpu6502.AsmGen6502()
+    else if (compilerOptions.compTarget.name == VMTarget.NAME)
+        VmCodeGen()
+    else
+        throw NotImplementedError("no asm generator for cpu ${compilerOptions.compTarget.machine.cpu}")
 
-//    println("*********** COMPILER AST RIGHT BEFORE ASM GENERATION *************")
-//    printProgram(program)
-
-    val assembly = asmGeneratorFor(program, errors, symbolTable, compilerOptions).compileToAssembly()
+    val stMaker = SymbolTableMaker(program, compilerOptions)
+    val symbolTable = stMaker.make()
+    val assembly = asmgen.generate(program, symbolTable, compilerOptions, errors)
     errors.report()
 
     return if(assembly!=null && errors.noErrors()) {
@@ -412,51 +421,3 @@ private fun createAssemblyAndAssemble(program: Program,
         false
     }
 }
-
-private fun removeAllVardeclsFromAst(program: Program) {
-    // remove all VarDecl nodes from the AST.
-    // code generation doesn't require them anymore, it operates only on the 'variables' collection.
-
-    class SearchAndRemove: IAstVisitor {
-        private val allVars = mutableListOf<VarDecl>()
-        init {
-            visit(program)
-            for (it in allVars) {
-                require((it.parent as IStatementContainer).statements.remove(it))
-            }
-        }
-        override fun visit(decl: VarDecl) {
-            allVars.add(decl)
-        }
-    }
-
-    SearchAndRemove()
-}
-
-fun printProgram(program: Program) {
-    println()
-    val printer = AstToSourceTextConverter(::print, program)
-    printer.visit(program)
-    println()
-}
-
-internal fun asmGeneratorFor(program: Program,
-                             errors: IErrorReporter,
-                             symbolTable: SymbolTable,
-                             options: CompilationOptions): IAssemblyGenerator
-{
-    if(options.experimentalCodegen) {
-        val intermediateAst = IntermediateAstMaker(program, symbolTable, options).transform()
-        return prog8.codegen.experimental.CodeGen(intermediateAst, symbolTable, options, errors)
-    } else {
-        if (options.compTarget.machine.cpu in arrayOf(CpuType.CPU6502, CpuType.CPU65c02))
-            // TODO rewrite 6502 codegen on new Intermediary Ast or on new Intermediate Representation
-            return prog8.codegen.cpu6502.AsmGen(program, symbolTable, options, errors)
-        if (options.compTarget.name == VMTarget.NAME) {
-            val intermediateAst = IntermediateAstMaker(program, symbolTable, options).transform()
-            return VmCodeGen(intermediateAst, symbolTable, options, errors)
-        }
-    }
-
-    throw NotImplementedError("no asm generator for cpu ${options.compTarget.machine.cpu}")
-}

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -8,8 +8,6 @@ import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
 import prog8.code.core.*
 import prog8.code.target.VMTarget
-import prog8.compiler.BuiltinFunctions
-import prog8.compiler.InplaceModifyingBuiltinFunctions
 import prog8.compiler.builtinFunctionReturnType
 import java.io.CharConversionException
 import java.io.File
@@ -62,12 +60,14 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(identifier: IdentifierReference) {
-        val targetParam = identifier.targetVarDecl(program)?.subroutineParameter
-        if(targetParam!=null) {
-            if((targetParam.parent as Subroutine).isAsmSubroutine)
+        val target = identifier.targetVarDecl(program)
+        if(target != null && target.origin==VarDeclOrigin.SUBROUTINEPARAM) {
+            if(target.definingSubroutine!!.isAsmSubroutine) {
+                if(target.definingSubroutine!!.parameters.any { it.name == identifier.nameInSource.last() })
                     errors.err("cannot refer to parameter of asmsub by name", identifier.position)
             }
         }
+    }
 
     override fun visit(returnStmt: Return) {
         val expectedReturnValues = returnStmt.definingSubroutine?.returntypes ?: emptyList()
@@ -664,9 +664,13 @@ internal class AstChecker(private val program: Program,
                     err("string var must be initialized with a string literal")
             }
 
-            if(decl.value !is StringLiteral)
+            if(decl.value !is StringLiteral) {
+                if(decl.type==VarDeclType.MEMORY)
+                    err("strings can't be memory mapped")
+                else
                     err("string var must be initialized with a string literal")
             }
+        }
 
         if(compilerOptions.zeropage==ZeropageType.DONTUSE && decl.zeropage == ZeropageWish.REQUIRE_ZEROPAGE)
             err("zeropage usage has been disabled by options")

compiler/src/prog8/compiler/astprocessing/AstExtensions.kt

@@ -136,12 +136,8 @@ internal fun Program.checkIdentifiers(errors: IErrorReporter, options: Compilati
 internal fun Program.variousCleanups(errors: IErrorReporter, options: CompilationOptions) {
     val process = VariousCleanups(this, errors, options)
     process.visit(this)
-    if(errors.noErrors()) {
-        if(process.applyModifications()>0) {
+    while(errors.noErrors() && process.applyModifications()>0) {
         process.visit(this)
-            if(errors.noErrors())
-                process.applyModifications()
-        }
     }
 }
 

compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt

@@ -7,11 +7,11 @@ import prog8.ast.expressions.FunctionCallExpression
 import prog8.ast.expressions.StringLiteral
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.BuiltinFunctions
 import prog8.code.core.ICompilationTarget
 import prog8.code.core.IErrorReporter
 import prog8.code.core.Position
 import prog8.code.target.VMTarget
-import prog8.compiler.BuiltinFunctions
 
 
 internal class AstIdentifiersChecker(private val errors: IErrorReporter,
@@ -92,7 +92,7 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
             val paramsToCheck = paramNames.intersect(namesInSub)
             for(name in paramsToCheck) {
                 val symbol = subroutine.searchSymbol(name)
-                if(symbol!=null && (symbol as? VarDecl)?.subroutineParameter==null)
+                if(symbol!=null && (symbol as? VarDecl)?.origin!=VarDeclOrigin.SUBROUTINEPARAM)
                     nameError(name, symbol.position, subroutine)
             }
 
@@ -163,7 +163,7 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
                     val pos = (if(call.args.any()) call.args[0] else (call as Node)).position
                     errors.err("invalid number of arguments", pos)
                 }
-                if(func.name=="memory") {
+                if(target.name=="memory") {
                     val name = call.args[0] as? StringLiteral
                     if(name!=null) {
                         val processed = name.value.map {

compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt

@@ -90,7 +90,7 @@ internal class BeforeAsmAstChanger(val program: Program,
                                 "unknown dt"
                             )
                             }, sourceDt, implicit=true)
-                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.BEFOREASMGEN, assignment.position)
+                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.ASMGEN, assignment.position)
                             return listOf(
                                 IAstModification.InsertBefore(assignment, assignRight, parent as IStatementContainer),
                                 IAstModification.ReplaceNode(binExpr.right, binExpr.left, binExpr),
@@ -103,7 +103,7 @@ internal class BeforeAsmAstChanger(val program: Program,
                             "unknown dt"
                         )
                         }, sourceDt, implicit=true)
-                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.BEFOREASMGEN, assignment.position)
+                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.ASMGEN, assignment.position)
                         return listOf(
                             IAstModification.InsertBefore(assignment, assignLeft, parent as IStatementContainer),
                             IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr)
@@ -293,7 +293,7 @@ internal class BeforeAsmAstChanger(val program: Program,
         val dt = expr.indexer.indexExpr.inferType(program)
         val (tempVarName, _) = program.getTempVar(dt.getOrElse { throw FatalAstException("invalid dt") })
         val target = AssignTarget(IdentifierReference(tempVarName, expr.indexer.position), null, null, expr.indexer.position)
-        val assign = Assignment(target, expr.indexer.indexExpr, AssignmentOrigin.BEFOREASMGEN, expr.indexer.position)
+        val assign = Assignment(target, expr.indexer.indexExpr, AssignmentOrigin.ASMGEN, expr.indexer.position)
         modifications.add(IAstModification.InsertBefore(statement, assign, statement.parent as IStatementContainer))
         modifications.add(
             IAstModification.ReplaceNode(

compiler/src/prog8/compiler/astprocessing/BoolRemover.kt

@@ -30,7 +30,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                     newvalue = NumericLiteral(DataType.UBYTE, 1.0, newvalue.position)
             }
             val ubyteDecl = VarDecl(decl.type, decl.origin, DataType.UBYTE, decl.zeropage, decl.arraysize, decl.name,
-                newvalue, decl.isArray, decl.sharedWithAsm, decl.subroutineParameter, decl.position)
+                newvalue, decl.isArray, decl.sharedWithAsm, decl.position)
             return listOf(IAstModification.ReplaceNode(decl, ubyteDecl, parent))
         }
 
@@ -47,7 +47,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                 newarray = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_UB), convertedArray, decl.position)
             }
             val ubyteArrayDecl = VarDecl(decl.type, decl.origin, DataType.ARRAY_UB, decl.zeropage, decl.arraysize, decl.name,
-                newarray, true, decl.sharedWithAsm, decl.subroutineParameter, decl.position)
+                newarray, true, decl.sharedWithAsm, decl.position)
             return listOf(IAstModification.ReplaceNode(decl, ubyteArrayDecl, parent))
         }
 

compiler/src/prog8/compiler/astprocessing/IntermediateAstMaker.kt

@@ -8,12 +8,11 @@ import prog8.ast.Program
 import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
-import prog8.code.SymbolTable
 import prog8.code.ast.*
+import prog8.code.core.BuiltinFunctions
 import prog8.code.core.CompilationOptions
 import prog8.code.core.DataType
 import prog8.code.core.SourceCode
-import prog8.compiler.BuiltinFunctions
 import prog8.compiler.builtinFunctionReturnType
 import java.io.File
 import kotlin.io.path.Path
@@ -23,7 +22,7 @@ import kotlin.io.path.isRegularFile
 /**
  *  Convert 'old' compiler-AST into the 'new' simplified AST with baked types.
  */
-class IntermediateAstMaker(private val program: Program, private val symbolTable: SymbolTable, private val options: CompilationOptions) {
+class IntermediateAstMaker(private val program: Program, private val options: CompilationOptions) {
     fun transform(): PtProgram {
         val ptProgram = PtProgram(
             program.name,
@@ -130,7 +129,8 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
             }
         }
         val (vardecls, statements) = srcBlock.statements.partition { it is VarDecl }
-        val block = PtBlock(srcBlock.name, srcBlock.address, srcBlock.isInLibrary, forceOutput, alignment, srcBlock.position)
+        val src = srcBlock.definingModule.source
+        val block = PtBlock(srcBlock.name, srcBlock.address, srcBlock.isInLibrary, forceOutput, alignment, src, srcBlock.position)
         makeScopeVarsDecls(vardecls).forEach { block.add(it) }
         for (stmt in statements)
             block.add(transformStatement(stmt))
@@ -285,18 +285,15 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
     }
 
     private fun transformAsmSub(srcSub: Subroutine): PtAsmSub {
-        val params = srcSub.parameters
-            .map { PtSubroutineParameter(it.name, it.type, it.position) }
-            .zip(srcSub.asmParameterRegisters)
+        val params = srcSub.asmParameterRegisters.zip(srcSub.parameters.map { PtSubroutineParameter(it.name, it.type, it.position) })
         val sub = PtAsmSub(srcSub.name,
             srcSub.asmAddress,
             srcSub.asmClobbers,
             params,
-            srcSub.returntypes,
-            srcSub.asmReturnvaluesRegisters,
+            srcSub.asmReturnvaluesRegisters.zip(srcSub.returntypes),
             srcSub.inline,
             srcSub.position)
-        sub.parameters.forEach { it.first.parent=sub }
+        sub.parameters.forEach { it.second.parent=sub }
 
         if(srcSub.asmAddress==null) {
             var combinedTrueAsm = ""
@@ -329,10 +326,11 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
         var returntype = srcSub.returntypes.singleOrNull()
         if(returntype==DataType.STR)
             returntype=DataType.UWORD   // if a sub returns 'str', replace with uword.  Intermediate AST and I.R. don't contain 'str' datatype anymore.
+
+        // do not bother about the 'inline' hint of the source subroutine.
         val sub = PtSub(srcSub.name,
             srcSub.parameters.map { PtSubroutineParameter(it.name, it.type, it.position) },
             returntype,
-            srcSub.inline,
             srcSub.position)
         sub.parameters.forEach { it.parent=sub }
         makeScopeVarsDecls(vardecls).forEach { sub.add(it) }
@@ -346,7 +344,7 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
         return when(srcVar.type) {
             VarDeclType.VAR -> {
                 val value = if(srcVar.value!=null) transformExpression(srcVar.value!!) else null
-                PtVariable(srcVar.name, srcVar.datatype, value, srcVar.arraysize?.constIndex()?.toUInt(), srcVar.position)
+                PtVariable(srcVar.name, srcVar.datatype, srcVar.zeropage, value, srcVar.arraysize?.constIndex()?.toUInt(), srcVar.position)
             }
             VarDeclType.CONST -> PtConstant(srcVar.name, srcVar.datatype, (srcVar.value as NumericLiteral).number, srcVar.position)
             VarDeclType.MEMORY -> PtMemMapped(srcVar.name, srcVar.datatype, (srcVar.value as NumericLiteral).number.toUInt(), srcVar.arraysize?.constIndex()?.toUInt(), srcVar.position)
@@ -385,8 +383,8 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
     }
 
     private fun transform(srcArr: ArrayIndexedExpression): PtArrayIndexer {
-        val type = srcArr.inferType(program).getOrElse { throw FatalAstException("unknown dt") }
-        val array = PtArrayIndexer(type, srcArr.position)
+        val arrayVarType = srcArr.inferType(program).getOrElse { throw FatalAstException("unknown dt") }
+        val array = PtArrayIndexer(arrayVarType, srcArr.position)
         array.add(transform(srcArr.arrayvar))
         array.add(transformExpression(srcArr.indexer.indexExpr))
         return array
@@ -464,6 +462,7 @@ class IntermediateAstMaker(private val program: Program, private val symbolTable
     private fun transform(srcCast: TypecastExpression): PtTypeCast {
         val cast = PtTypeCast(srcCast.type, srcCast.position)
         cast.add(transformExpression(srcCast.expression))
+        require(cast.type!=cast.value.type)
         return cast
     }
 

compiler/src/prog8/compiler/astprocessing/NotExpressionAndIfComparisonExprChanger.kt

@@ -178,7 +178,7 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             leftAssignment = Assignment(
                 AssignTarget(IdentifierReference(name, expr.position), null, null, expr.position),
                 expr.left.copy(),
-                AssignmentOrigin.BEFOREASMGEN, expr.position
+                AssignmentOrigin.ASMGEN, expr.position
             )
         }
         if(separateRightExpr) {
@@ -187,7 +187,7 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             rightAssignment = Assignment(
                 AssignTarget(IdentifierReference(tempVarName, expr.position), null, null, expr.position),
                 expr.right.copy(),
-                AssignmentOrigin.BEFOREASMGEN, expr.position
+                AssignmentOrigin.ASMGEN, expr.position
             )
         }
         return CondExprSimplificationResult(

compiler/src/prog8/compiler/astprocessing/StatementReorderer.kt

@@ -153,7 +153,7 @@ internal class StatementReorderer(val program: Program,
                     subroutine.statements
                         .asSequence()
                         .filterIsInstance<VarDecl>()
-                        .filter { it.subroutineParameter!=null && it.name in stringParamsByNames }
+                        .filter { it.origin==VarDeclOrigin.SUBROUTINEPARAM && it.name in stringParamsByNames }
                         .map {
                             val newvar = VarDecl(it.type, it.origin, DataType.UWORD,
                                 it.zeropage,
@@ -162,7 +162,6 @@ internal class StatementReorderer(val program: Program,
                                 null,
                                 false,
                                 it.sharedWithAsm,
-                                stringParamsByNames.getValue(it.name),
                                 it.position
                             )
                             IAstModification.ReplaceNode(it, newvar, subroutine)

compiler/src/prog8/compiler/astprocessing/SymbolTableMaker.kt

@@ -1,138 +0,0 @@
-package prog8.compiler.astprocessing
-
-import prog8.ast.Program
-import prog8.ast.base.FatalAstException
-import prog8.ast.expressions.*
-import prog8.ast.statements.*
-import prog8.ast.walk.IAstVisitor
-import prog8.code.*
-import prog8.code.core.ArrayDatatypes
-import prog8.code.core.CompilationOptions
-import prog8.code.core.DataType
-import prog8.code.core.Position
-import java.util.*
-
-internal class SymbolTableMaker(private val program: Program, private val options: CompilationOptions): IAstVisitor {
-
-    private val st = SymbolTable()
-    private val scopestack = Stack<StNode>()
-    private var dontReinitGlobals = false
-
-    fun make(): SymbolTable {
-        scopestack.clear()
-        st.children.clear()
-        dontReinitGlobals = options.dontReinitGlobals
-        this.visit(program)
-        program.builtinFunctions.names.forEach {
-            val node = StNode(it, StNodeType.BUILTINFUNC, Position.DUMMY)
-            st.add(node)
-        }
-        require(scopestack.isEmpty())
-        return st
-    }
-
-    override fun visit(block: Block) {
-        val node = StNode(block.name, StNodeType.BLOCK, block.position)
-        st.add(node)
-        scopestack.push(node)
-        super.visit(block)
-        scopestack.pop()
-        // st.origAstLinks[block] = node
-    }
-
-    override fun visit(subroutine: Subroutine) {
-        if(subroutine.asmAddress!=null) {
-            val parameters = subroutine.parameters.zip(subroutine.asmParameterRegisters).map { StRomSubParameter(it.second, it.first.type) }
-            val node = StRomSub(subroutine.name, subroutine.asmAddress!!, parameters, subroutine.asmReturnvaluesRegisters, subroutine.position)
-            scopestack.peek().add(node)
-            // st.origAstLinks[subroutine] = node
-        } else {
-            val parameters = subroutine.parameters.map { StSubroutineParameter(it.name, it.type) }
-            val returnType = if(subroutine.returntypes.isEmpty()) null else subroutine.returntypes.first()
-            val node = StSub(subroutine.name, parameters, returnType, subroutine.position)
-            scopestack.peek().add(node)
-            scopestack.push(node)
-            super.visit(subroutine)
-            scopestack.pop()
-            // st.origAstLinks[subroutine] = node
-        }
-    }
-
-    override fun visit(decl: VarDecl) {
-        val node =
-            when(decl.type) {
-                VarDeclType.VAR -> {
-                    var initialNumeric = (decl.value as? NumericLiteral)?.number
-                    if(initialNumeric==0.0)
-                        initialNumeric=null     // variable will go into BSS and this will be set to 0
-                    val initialStringLit = decl.value as? StringLiteral
-                    val initialString = if(initialStringLit==null) null else Pair(initialStringLit.value, initialStringLit.encoding)
-                    val initialArrayLit = decl.value as? ArrayLiteral
-                    val initialArray = makeInitialArray(initialArrayLit)
-                    if(decl.isArray && decl.datatype !in ArrayDatatypes)
-                        throw FatalAstException("array vardecl has mismatched dt ${decl.datatype}")
-                    val numElements =
-                        if(decl.isArray)
-                            decl.arraysize!!.constIndex()
-                        else if(initialStringLit!=null)
-                            initialStringLit.value.length+1  // include the terminating 0-byte
-                        else
-                            null
-                    val bss = if(decl.datatype==DataType.STR)
-                        false
-                    else if(decl.isArray)
-                        initialArray.isNullOrEmpty()
-                    else
-                        initialNumeric == null
-                    StStaticVariable(decl.name, decl.datatype, bss, initialNumeric, initialString, initialArray, numElements, decl.zeropage, decl.position)
-                }
-                VarDeclType.CONST -> StConstant(decl.name, decl.datatype, (decl.value as NumericLiteral).number, decl.position)
-                VarDeclType.MEMORY -> {
-                    val numElements =
-                        if(decl.datatype in ArrayDatatypes)
-                            decl.arraysize!!.constIndex()
-                        else null
-                    StMemVar(decl.name, decl.datatype, (decl.value as NumericLiteral).number.toUInt(), numElements, decl.position)
-                }
-            }
-        scopestack.peek().add(node)
-        // st.origAstLinks[decl] = node
-    }
-
-    private fun makeInitialArray(arrayLit: ArrayLiteral?): StArray? {
-        if(arrayLit==null)
-            return null
-        return arrayLit.value.map {
-            when(it){
-                is AddressOf -> {
-                    val scopedName = it.identifier.targetNameAndType(program).first
-                    StArrayElement(null, scopedName)
-                }
-                is IdentifierReference -> {
-                    val scopedName = it.targetNameAndType(program).first
-                    StArrayElement(null, scopedName)
-                }
-                is NumericLiteral -> StArrayElement(it.number, null)
-                else -> throw FatalAstException("weird element dt in array literal")
-            }
-        }.toList()
-    }
-
-    override fun visit(label: Label) {
-        val node = StNode(label.name, StNodeType.LABEL, label.position)
-        scopestack.peek().add(node)
-        // st.origAstLinks[label] = node
-    }
-
-    override fun visit(bfc: BuiltinFunctionCall) {
-        if(bfc.name=="memory") {
-            // memory slab allocations are a builtin functioncall in the program, but end up named as well in the symboltable
-            val name = (bfc.args[0] as StringLiteral).value
-            require(name.all { it.isLetterOrDigit() || it=='_' }) {"memory name should be a valid symbol name"}
-            val size = (bfc.args[1] as NumericLiteral).number.toUInt()
-            val align = (bfc.args[2] as NumericLiteral).number.toUInt()
-            st.add(StMemorySlab("prog8_memoryslab_$name", size, align, bfc.position))
-        }
-        super.visit(bfc)
-    }
-}

compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt

@@ -9,7 +9,6 @@ import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
-import prog8.compiler.BuiltinFunctions
 
 
 class TypecastsAdder(val program: Program, val options: CompilationOptions, val errors: IErrorReporter) : AstWalker() {

compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt

@@ -40,7 +40,7 @@ internal class VariousCleanups(val program: Program, val errors: IErrorReporter,
         }
 
         val sourceDt = typecast.expression.inferType(program)
-        if(sourceDt istype typecast.type)
+        if(sourceDt istype typecast.type || (sourceDt istype DataType.BOOL && typecast.type==DataType.UBYTE))
             return listOf(IAstModification.ReplaceNode(typecast, typecast.expression, parent))
 
         if(parent is Assignment) {
@@ -62,6 +62,11 @@ internal class VariousCleanups(val program: Program, val errors: IErrorReporter,
     }
 
     override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
+        if(assignment.target isSameAs assignment.value) {
+            // remove assignment to self
+            return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
+        }
+
         // remove duplicated assignments, but not if it's a memory mapped IO register
         val isIO = try {
             assignment.target.isIOAddress(options.compTarget.machine)

compiler/src/prog8/compiler/astprocessing/VerifyFunctionArgTypes.kt

@@ -5,11 +5,7 @@ import prog8.ast.Program
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
-import prog8.code.core.ByteDatatypes
-import prog8.code.core.DataType
-import prog8.code.core.IErrorReporter
-import prog8.code.core.Position
-import prog8.compiler.BuiltinFunctions
+import prog8.code.core.*
 
 internal class VerifyFunctionArgTypes(val program: Program, val errors: IErrorReporter) : IAstVisitor {
 

compiler/test/TestBuiltinFunctions.kt

@@ -3,31 +3,19 @@ package prog8tests
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import prog8.ast.expressions.NumericLiteral
+import prog8.ast.statements.Assignment
+import prog8.code.core.BuiltinFunctions
 import prog8.code.core.DataType
 import prog8.code.core.NumericDatatypesNoBool
 import prog8.code.core.RegisterOrPair
 import prog8.code.target.Cx16Target
-import prog8.compiler.BuiltinFunctions
 import prog8tests.helpers.compileText
 
 class TestBuiltinFunctions: FunSpec({
 
-    test("push pop") {
-        val src="""
-            main  {
-                sub start () { 
-                    pushw(cx16.r0)
-                    push(cx16.r1L)
-                    pop(cx16.r1L)
-                    popw(cx16.r0)
-                }
-            }"""
-        compileText(Cx16Target(), false, src, writeAssembly = true) shouldNotBe null
-    }
-
     test("pure func with fixed type") {
         val func = BuiltinFunctions.getValue("sgn")
-        func.name shouldBe "sgn"
         func.parameters.size shouldBe 1
         func.parameters[0].name shouldBe "value"
         func.parameters[0].possibleDatatypes shouldBe NumericDatatypesNoBool
@@ -46,7 +34,6 @@ class TestBuiltinFunctions: FunSpec({
 
     test("not-pure func with varying result value type") {
         val func = BuiltinFunctions.getValue("cmp")
-        func.name shouldBe "cmp"
         func.parameters.size shouldBe 2
         func.pure shouldBe false
         func.returnType shouldBe null
@@ -60,7 +47,6 @@ class TestBuiltinFunctions: FunSpec({
 
     test("func without return type") {
         val func = BuiltinFunctions.getValue("poke")
-        func.name shouldBe "poke"
         func.parameters.size shouldBe 2
         func.parameters[0].name shouldBe "address"
         func.parameters[0].possibleDatatypes shouldBe arrayOf(DataType.UWORD)
@@ -81,5 +67,44 @@ class TestBuiltinFunctions: FunSpec({
         conv.returns.floatFac1 shouldBe false
         conv.returns.reg shouldBe null
     }
+
+    test("push pop") {
+        val src="""
+            main  {
+                sub start () { 
+                    pushw(cx16.r0)
+                    push(cx16.r1L)
+                    pop(cx16.r1L)
+                    popw(cx16.r0)
+                }
+            }"""
+        compileText(Cx16Target(), false, src, writeAssembly = true) shouldNotBe null
+    }
+
+    test("certain builtin functions should be compile time evaluated") {
+        val src="""
+main {
+    sub start() {
+
+        uword[] array = [1,2,3]
+        str name = "hello"
+        cx16.r0L = len(array)
+        cx16.r0L = len(name)
+        cx16.r0L = sizeof(array)
+        cx16.r0 = mkword(200,100)
+    }
+}"""
+        val result = compileText(Cx16Target(), false, src, writeAssembly = false)
+        val statements = result!!.compilerAst.entrypoint.statements
+        statements.size shouldBe 6
+        val a1 = statements[2] as Assignment
+        val a2 = statements[3] as Assignment
+        val a3 = statements[4] as Assignment
+        val a4 = statements[5] as Assignment
+        (a1.value as NumericLiteral).number shouldBe 3.0
+        (a2.value as NumericLiteral).number shouldBe 5.0
+        (a3.value as NumericLiteral).number shouldBe 6.0
+        (a4.value as NumericLiteral).number shouldBe 200*256+100
+    }
 })
 

compiler/test/TestCallgraph.kt

@@ -27,11 +27,11 @@ class TestCallgraph: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, sourcecode)!!
-        val graph = CallGraph(result.program)
+        val graph = CallGraph(result.compilerAst)
 
         graph.imports.size shouldBe 1
         graph.importedBy.size shouldBe 1
-        val toplevelModule = result.program.toplevelModule
+        val toplevelModule = result.compilerAst.toplevelModule
         val importedModule = graph.imports.getValue(toplevelModule).single()
         importedModule.name shouldBe "string"
         val importedBy = graph.importedBy.getValue(importedModule).single()
@@ -46,7 +46,7 @@ class TestCallgraph: FunSpec({
             graph.calls shouldNotContainKey sub
             graph.calledBy shouldNotContainKey sub
 
-            if(sub === result.program.entrypoint)
+            if(sub === result.compilerAst.entrypoint)
                 withClue("start() should always be marked as used to avoid having it removed") {
                     graph.unused(sub) shouldBe false
                 }
@@ -68,11 +68,11 @@ class TestCallgraph: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, sourcecode)!!
-        val graph = CallGraph(result.program)
+        val graph = CallGraph(result.compilerAst)
 
         graph.imports.size shouldBe 1
         graph.importedBy.size shouldBe 1
-        val toplevelModule = result.program.toplevelModule
+        val toplevelModule = result.compilerAst.toplevelModule
         val importedModule = graph.imports.getValue(toplevelModule).single()
         importedModule.name shouldBe "string"
         val importedBy = graph.importedBy.getValue(importedModule).single()
@@ -111,7 +111,7 @@ class TestCallgraph: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, sourcecode)!!
-        val graph = CallGraph(result.program)
+        val graph = CallGraph(result.compilerAst)
         graph.allIdentifiers.size shouldBeGreaterThanOrEqual 5
         val empties = graph.allIdentifiers.keys.filter { it.nameInSource==listOf("empty") }
         empties.size shouldBe 3

compiler/test/TestCompilerOnCharLit.kt

@@ -33,7 +33,7 @@ class TestCompilerOnCharLit: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val funCall = startSub.statements.filterIsInstance<IFunctionCall>()[0]
 
@@ -57,7 +57,7 @@ class TestCompilerOnCharLit: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val funCall = startSub.statements.filterIsInstance<IFunctionCall>()[0]
 
@@ -92,7 +92,7 @@ class TestCompilerOnCharLit: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val funCall = startSub.statements.filterIsInstance<IFunctionCall>()[0]
 

compiler/test/TestCompilerOnExamples.kt

@@ -188,8 +188,8 @@ class TestCompilerOnExamplesVirtual: FunSpec({
         val (displayName, filepath) = prepareTestFiles(it, false, target)
         test(displayName) {
             val src = filepath.readText()
-            compileText(target, false, src, writeAssembly = true) shouldNotBe null
-            compileText(target, false, src, writeAssembly = true) shouldNotBe null
+            compileText(target, true, src, writeAssembly = true) shouldNotBe null
+            compileText(target, true, src, writeAssembly = true) shouldNotBe null
         }
     }
 })

compiler/test/TestCompilerOnImportsAndIncludes.kt

@@ -30,7 +30,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val platform = Cx16Target()
             val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)!!
 
-            val program = result.program
+            val program = result.compilerAst
             val startSub = program.entrypoint
             val strLits = startSub.statements
                 .filterIsInstance<FunctionCallStatement>()
@@ -52,7 +52,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val platform = Cx16Target()
             val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)!!
 
-            val program = result.program
+            val program = result.compilerAst
             val startSub = program.entrypoint
             val args = startSub.statements
                 .filterIsInstance<FunctionCallStatement>()

compiler/test/TestCompilerOnRanges.kt

@@ -40,7 +40,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val decl = startSub
             .statements.filterIsInstance<VarDecl>()[0]
@@ -72,7 +72,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val decl = startSub
             .statements.filterIsInstance<VarDecl>()[0]
@@ -143,7 +143,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val iterable = startSub
             .statements.filterIsInstance<ForLoop>()
@@ -177,7 +177,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val rangeExpr = startSub
             .statements.filterIsInstance<ForLoop>()
@@ -203,7 +203,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val rangeExpr = startSub
             .statements.filterIsInstance<ForLoop>()
@@ -247,7 +247,7 @@ class TestCompilerOnRanges: FunSpec({
             }
         """)!!
 
-        val program = result.program
+        val program = result.compilerAst
         val startSub = program.entrypoint
         val iterable = startSub
             .statements.filterIsInstance<ForLoop>()
@@ -279,7 +279,7 @@ class TestCompilerOnRanges: FunSpec({
                 }
             }
         """)!!
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         val array = (statements[0] as VarDecl).value
         array shouldBe instanceOf<ArrayLiteral>()
         (array as ArrayLiteral).value.size shouldBe 26
@@ -301,7 +301,7 @@ class TestCompilerOnRanges: FunSpec({
                 }
             }
         """)!!
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         val forloop = (statements.dropLast(1).last() as ForLoop)
         forloop.iterable shouldBe instanceOf<RangeExpression>()
         (forloop.iterable as RangeExpression).step shouldBe NumericLiteral(DataType.UBYTE, -2.0, Position.DUMMY)

compiler/test/TestImportedModulesOrderAndOptions.kt

@@ -28,9 +28,9 @@ main {
     }
 }
 """)!!
-        result.program.toplevelModule.name shouldStartWith "on_the_fly_test"
+        result.compilerAst.toplevelModule.name shouldStartWith "on_the_fly_test"
 
-        val moduleNames = result.program.modules.map { it.name }
+        val moduleNames = result.compilerAst.modules.map { it.name }
         withClue("main module must be first") {
             moduleNames[0] shouldStartWith "on_the_fly_test"
         }
@@ -46,7 +46,7 @@ main {
                 "prog8_lib"
             )
         }
-        result.program.toplevelModule.name shouldStartWith "on_the_fly_test"
+        result.compilerAst.toplevelModule.name shouldStartWith "on_the_fly_test"
     }
 
     test("testCompilationOptionsCorrectFromMain") {
@@ -63,8 +63,8 @@ main {
     }
 }
 """)!!
-        result.program.toplevelModule.name shouldStartWith "on_the_fly_test"
-        val options = determineCompilationOptions(result.program, C64Target())
+        result.compilerAst.toplevelModule.name shouldStartWith "on_the_fly_test"
+        val options = determineCompilationOptions(result.compilerAst, C64Target())
         options.floats shouldBe true
         options.zeropage shouldBe ZeropageType.DONTUSE
         options.noSysInit shouldBe true

compiler/test/TestMemory.kt

@@ -15,7 +15,6 @@ import prog8.code.core.Position
 import prog8.code.core.SourceCode
 import prog8.code.core.ZeropageWish
 import prog8.code.target.C64Target
-import prog8.compiler.printProgram
 import prog8tests.helpers.DummyFunctions
 import prog8tests.helpers.DummyMemsizer
 import prog8tests.helpers.DummyStringEncoder
@@ -28,7 +27,7 @@ class TestMemory: FunSpec({
 
     fun wrapWithProgram(statements: List<Statement>): Program {
         val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
-        val subroutine = Subroutine("test", mutableListOf(), emptyList(), statements.toMutableList(), false, Position.DUMMY)
+        val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, statements.toMutableList(), Position.DUMMY)
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         program.addModule(module)
         return program
@@ -113,7 +112,7 @@ class TestMemory: FunSpec({
     }
 
     fun createTestProgramForMemoryRefViaVar(address: UInt, vartype: VarDeclType): AssignTarget {
-        val decl = VarDecl(vartype, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(vartype, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val memexpr = IdentifierReference(listOf("address"), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -147,12 +146,11 @@ class TestMemory: FunSpec({
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        printProgram(target.definingModule.program)
         target.isIOAddress(c64target.machine) shouldBe true
     }
 
     test("regular variable not in mapped IO ram on C64") {
-        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -164,7 +162,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped variable not in mapped IO ram on C64") {
         val address = 0x1000u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -176,7 +174,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped variable in mapped IO ram on C64") {
         val address = 0xd020u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, mutableListOf(decl, assignment), Position.DUMMY)
@@ -187,7 +185,7 @@ class TestMemory: FunSpec({
     }
 
     test("array not in mapped IO ram") {
-        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -200,7 +198,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped array not in mapped IO ram") {
         val address = 0x1000u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
@@ -213,7 +211,7 @@ class TestMemory: FunSpec({
 
     test("memory mapped array in mapped IO ram") {
         val address = 0xd800u
-        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, null, Position.DUMMY)
+        val decl = VarDecl(VarDeclType.MEMORY, VarDeclOrigin.USERCODE, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", NumericLiteral.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteral.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteral.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)

compiler/test/TestNumbers.kt

@@ -14,7 +14,6 @@ import prog8.code.core.Position
 import prog8.code.core.toHex
 import prog8.code.target.C64Target
 import prog8.code.target.cbm.Mflpt5
-import prog8.compiler.printProgram
 import prog8tests.helpers.ErrorReporterForTests
 import prog8tests.helpers.compileText
 
@@ -199,9 +198,8 @@ class TestNumbers: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, src, writeAssembly = false)!!
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         statements.size shouldBe 8
-        printProgram(result.program)
         (statements[1] as Assignment).value shouldBe NumericLiteral(DataType.UWORD, 32768.0, Position.DUMMY)
         (statements[3] as Assignment).value shouldBe NumericLiteral(DataType.UWORD, 65535.0, Position.DUMMY)
         (statements[5] as Assignment).value shouldBe NumericLiteral(DataType.UBYTE, 255.0, Position.DUMMY)

compiler/test/TestOptimization.kt

@@ -16,7 +16,6 @@ import prog8.code.core.DataType
 import prog8.code.core.Position
 import prog8.code.target.C64Target
 import prog8.code.target.Cx16Target
-import prog8.compiler.printProgram
 import prog8tests.helpers.*
 
 
@@ -32,10 +31,10 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), true, sourcecode)!!
-        val toplevelModule = result.program.toplevelModule
+        val toplevelModule = result.compilerAst.toplevelModule
         val mainBlock = toplevelModule.statements.single() as Block
         val startSub = mainBlock.statements.single() as Subroutine
-        result.program.entrypoint shouldBeSameInstanceAs startSub
+        result.compilerAst.entrypoint shouldBeSameInstanceAs startSub
         withClue("only start sub should remain") {
             startSub.name shouldBe "start"
         }
@@ -57,11 +56,11 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), true, sourcecode)!!
-        val toplevelModule = result.program.toplevelModule
+        val toplevelModule = result.compilerAst.toplevelModule
         val mainBlock = toplevelModule.statements.single() as Block
         val startSub = mainBlock.statements[0] as Subroutine
         val emptySub = mainBlock.statements[1] as Subroutine
-        result.program.entrypoint shouldBeSameInstanceAs startSub
+        result.compilerAst.entrypoint shouldBeSameInstanceAs startSub
         startSub.name shouldBe "start"
         emptySub.name shouldBe "empty"
         withClue("compiler has inserted return in empty subroutines") {
@@ -131,7 +130,7 @@ class TestOptimization: FunSpec({
 //        cx16.r5s -= 1899
 //        cx16.r7s = llw
 //        cx16.r7s += 99
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 14
 
         val addR0value = (stmts[5] as Assignment).value
@@ -183,7 +182,7 @@ class TestOptimization: FunSpec({
 //        cx16.r4s = llw
 //        cx16.r4s *= 90
 //        cx16.r4s /= 5
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 13
 
         val mulR0Value = (stmts[3] as Assignment).value
@@ -225,7 +224,7 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, sourcecode)!!
-        val mainsub = result.program.entrypoint
+        val mainsub = result.compilerAst.entrypoint
         mainsub.statements.size shouldBe 10
         val declTest = mainsub.statements[0] as VarDecl
         val declX1 = mainsub.statements[1] as VarDecl
@@ -265,8 +264,7 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, src, writeAssembly = true)!!
-        printProgram(result.program)
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 8
 
         val value1 = (stmts[4] as Assignment).value as BinaryExpression
@@ -298,7 +296,7 @@ class TestOptimization: FunSpec({
         bb = prog8_lib.retval_interm_b
         return
          */
-        val st = result.program.entrypoint.statements
+        val st = result.compilerAst.entrypoint.statements
         st.size shouldBe 8
         st.last() shouldBe instanceOf<Return>()
         var assign = st[3] as Assignment
@@ -324,7 +322,7 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), optimize=false, src, writeAssembly = false)!!
-        val assignFF = result.program.entrypoint.statements.last() as Assignment
+        val assignFF = result.compilerAst.entrypoint.statements.last() as Assignment
         assignFF.isAugmentable shouldBe true
         assignFF.target.identifier!!.nameInSource shouldBe listOf("ff")
         val value = assignFF.value as BinaryExpression
@@ -350,8 +348,8 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        result.program.entrypoint.statements.size shouldBe 7
-        val alldecls = result.program.entrypoint.allDefinedSymbols.toList()
+        result.compilerAst.entrypoint.statements.size shouldBe 7
+        val alldecls = result.compilerAst.entrypoint.allDefinedSymbols.toList()
         alldecls.map { it.first } shouldBe listOf("unused_but_shared", "usedvar_only_written", "usedvar")
     }
 
@@ -373,11 +371,11 @@ class TestOptimization: FunSpec({
                 }
             }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        result.program.entrypoint.statements.size shouldBe 3
-        val ifstmt = result.program.entrypoint.statements[0] as IfElse
+        result.compilerAst.entrypoint.statements.size shouldBe 3
+        val ifstmt = result.compilerAst.entrypoint.statements[0] as IfElse
         ifstmt.truepart.statements.size shouldBe 1
         (ifstmt.truepart.statements[0] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "r0")
-        val func2 = result.program.entrypoint.statements[2] as Subroutine
+        val func2 = result.compilerAst.entrypoint.statements[2] as Subroutine
         func2.statements.size shouldBe 1
         (func2.statements[0] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "r0")
     }
@@ -401,7 +399,6 @@ class TestOptimization: FunSpec({
                 }
             }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        printProgram(result.program)
         /* expected:
         ubyte z1
         z1 = 10
@@ -418,7 +415,7 @@ class TestOptimization: FunSpec({
         z6 = z1
         z6 -= 5
         */
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         statements.size shouldBe 14
         val z1decl = statements[0] as VarDecl
         val z1init = statements[1] as Assignment
@@ -469,7 +466,7 @@ class TestOptimization: FunSpec({
         """
 
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
         val assign=stmts.last() as Assignment
         (assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
@@ -486,7 +483,7 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
         val assign=stmts.last() as Assignment
         (assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
@@ -505,7 +502,7 @@ class TestOptimization: FunSpec({
             }
         """
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 10
         stmts.filterIsInstance<VarDecl>().size shouldBe 5
         stmts.filterIsInstance<Assignment>().size shouldBe 5
@@ -554,8 +551,8 @@ class TestOptimization: FunSpec({
             }
         }"""
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=true)!!
-        result.program.entrypoint.statements.size shouldBe 11
-        result.program.entrypoint.statements.last() shouldBe instanceOf<Return>()
+        result.compilerAst.entrypoint.statements.size shouldBe 11
+        result.compilerAst.entrypoint.statements.last() shouldBe instanceOf<Return>()
     }
 
     test("keep the value initializer assignment if the next one depends on it") {
@@ -582,7 +579,7 @@ class TestOptimization: FunSpec({
         xx = abs(xx)
         xx += 6
          */
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 8
         stmts.filterIsInstance<VarDecl>().size shouldBe 3
         stmts.filterIsInstance<Assignment>().size shouldBe 5
@@ -611,7 +608,7 @@ class TestOptimization: FunSpec({
         yy = 0
         xx += 10
          */
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 7
         stmts.filterIsInstance<VarDecl>().size shouldBe 2
         stmts.filterIsInstance<Assignment>().size shouldBe 5
@@ -638,7 +635,6 @@ class TestOptimization: FunSpec({
             }
         }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        printProgram(result.program)
         /*
         expected result:
         ubyte[] auto_heap_var = [1,4,99,3]
@@ -649,7 +645,7 @@ class TestOptimization: FunSpec({
         if source in auto_heap_var
             thingy++
          */
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
         val ifStmt = stmts[5] as IfElse
         val containment = ifStmt.condition as ContainmentCheck
@@ -679,8 +675,7 @@ class TestOptimization: FunSpec({
             }
         }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        printProgram(result.program)
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 5
         val ifStmt = stmts[4] as IfElse
         ifStmt.condition shouldBe instanceOf<BinaryExpression>()
@@ -698,8 +693,7 @@ class TestOptimization: FunSpec({
             }
         }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        printProgram(result.program)
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 5
         val ifStmt = stmts[4] as IfElse
         ifStmt.condition shouldBe instanceOf<BinaryExpression>()
@@ -717,7 +711,7 @@ class TestOptimization: FunSpec({
             }
         }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 5
         val ifStmt = stmts[4] as IfElse
         ifStmt.condition shouldBe instanceOf<BinaryExpression>()
@@ -734,7 +728,7 @@ class TestOptimization: FunSpec({
                 }
             }"""
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 3
     }
 
@@ -756,15 +750,15 @@ main {
     }
 }"""
         var result = compileText(Cx16Target(), true, srcX16, writeAssembly = true)!!
-        var statements = result.program.entrypoint.statements
+        var statements = result.compilerAst.entrypoint.statements
         statements.size shouldBe 9
         (statements[1] as Assignment).target.identifier!!.nameInSource shouldBe listOf("xx")
         (statements[2] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "VERA_DATA0")
         (statements[3] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "VERA_DATA0")
         (statements[4] as Assignment).target.identifier!!.nameInSource shouldBe listOf("cx16", "VERA_DATA0")
-        (statements[5] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 0x9fff
-        (statements[6] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 0x9fff
-        (statements[7] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 0x9fff
+        (statements[5] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 0x9fff
+        (statements[6] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 0x9fff
+        (statements[7] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 0x9fff
 
         val srcC64="""
 main {
@@ -783,15 +777,15 @@ main {
     }
 }"""
         result = compileText(C64Target(), true, srcC64, writeAssembly = true)!!
-        statements = result.program.entrypoint.statements
+        statements = result.compilerAst.entrypoint.statements
         statements.size shouldBe 9
         (statements[1] as Assignment).target.identifier!!.nameInSource shouldBe listOf("xx")
         (statements[2] as Assignment).target.identifier!!.nameInSource shouldBe listOf("c64", "EXTCOL")
         (statements[3] as Assignment).target.identifier!!.nameInSource shouldBe listOf("c64", "EXTCOL")
         (statements[4] as Assignment).target.identifier!!.nameInSource shouldBe listOf("c64", "EXTCOL")
-        (statements[5] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 53281.0
-        (statements[6] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 53281.0
-        (statements[7] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.program)!!.number shouldBe 53281.0
+        (statements[5] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 53281.0
+        (statements[6] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 53281.0
+        (statements[7] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 53281.0
     }
 
     test("no crash on sorting unused array") {

compiler/test/TestScoping.kt

@@ -27,9 +27,9 @@ class TestScoping: FunSpec({
         """
 
         val result = compileText(C64Target(), false, src, writeAssembly = false)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         module.parent shouldBe instanceOf<GlobalNamespace>()
-        module.program shouldBeSameInstanceAs result.program
+        module.program shouldBeSameInstanceAs result.compilerAst
         module.parent.parent shouldBe instanceOf<ParentSentinel>()
     }
 
@@ -46,7 +46,7 @@ class TestScoping: FunSpec({
         """
 
         val result = compileText(C64Target(), false, src, writeAssembly = false)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         val mainBlock = module.statements.single() as Block
         val start = mainBlock.statements.single() as Subroutine
         val repeatbody = start.statements.filterIsInstance<RepeatLoop>().single().body
@@ -120,7 +120,7 @@ class TestScoping: FunSpec({
         """
 
         val result = compileText(C64Target(), false, src, writeAssembly = true)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         val mainBlock = module.statements.single() as Block
         val start = mainBlock.statements.single() as Subroutine
         val labels = start.statements.filterIsInstance<Label>()

compiler/test/TestSubroutines.kt

@@ -60,7 +60,7 @@ class TestSubroutines: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
         val func = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="func"}
@@ -116,7 +116,7 @@ class TestSubroutines: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
         val func = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="func"}
@@ -178,7 +178,7 @@ class TestSubroutines: FunSpec({
         """
 
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val module = result.program.toplevelModule
+        val module = result.compilerAst.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
         val func = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="func"}
@@ -284,7 +284,7 @@ class TestSubroutines: FunSpec({
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
 
         stmts.last() shouldBe instanceOf<Subroutine>()
         stmts.dropLast(1).last() shouldBe instanceOf<Return>()  // this prevents the fallthrough

compiler/test/TestSymbolTable.kt

@@ -4,19 +4,26 @@ import io.kotest.assertions.fail
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import io.kotest.matchers.types.shouldBeSameInstanceAs
 import prog8.code.*
+import prog8.code.ast.*
 import prog8.code.core.DataType
 import prog8.code.core.Position
+import prog8.code.core.SourceCode
 import prog8.code.core.ZeropageWish
+import prog8tests.helpers.DummyMemsizer
+import prog8tests.helpers.DummyStringEncoder
+
 
 class TestSymbolTable: FunSpec({
     test("empty symboltable") {
-        val st = SymbolTable()
-        st.scopedName shouldBe ""
-        st.name shouldBe ""
+        val astNode = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val st = SymbolTable(astNode)
+        st.name shouldBe "test"
         st.type shouldBe StNodeType.GLOBAL
         st.children shouldBe mutableMapOf()
-        st.position shouldBe Position.DUMMY
+        st.astNode shouldBeSameInstanceAs astNode
+        st.astNode.position shouldBe Position.DUMMY
     }
 
     test("symboltable flatten") {
@@ -33,9 +40,9 @@ class TestSymbolTable: FunSpec({
         st.lookupUnscoped("undefined") shouldBe null
         st.lookup("undefined") shouldBe null
         st.lookup("undefined.undefined") shouldBe null
-        var default = st.lookupUnscopedOrElse("undefined") { StNode("default", StNodeType.LABEL, Position.DUMMY) }
+        var default = st.lookupUnscopedOrElse("undefined") { StNode("default", StNodeType.LABEL, PtIdentifier("default", DataType.BYTE, Position.DUMMY)) }
         default.name shouldBe "default"
-        default = st.lookupUnscopedOrElse("undefined") { StNode("default", StNodeType.LABEL, Position.DUMMY) }
+        default = st.lookupUnscopedOrElse("undefined") { StNode("default", StNodeType.LABEL, PtIdentifier("default", DataType.BYTE, Position.DUMMY)) }
         default.name shouldBe "default"
 
         val msbFunc = st.lookupUnscopedOrElse("msb") { fail("msb must be found") }
@@ -67,33 +74,71 @@ class TestSymbolTable: FunSpec({
         subsub.lookupUnscoped("blockc") shouldBe null
         subsub.lookupUnscoped("label") shouldNotBe null
     }
+
+    // TODO add more SymbolTable tests
+    
 })
 
 
 private fun makeSt(): SymbolTable {
-    val st = SymbolTable()
-    val block1 = StNode("block1", StNodeType.BLOCK, Position.DUMMY)
-    val sub11 = StNode("sub1", StNodeType.SUBROUTINE, Position.DUMMY)
-    val sub12 = StNode("sub2", StNodeType.SUBROUTINE, Position.DUMMY)
+
+    // first build the AST
+    val astProgram = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+    val astBlock1 = PtBlock("block1", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("block1"), Position.DUMMY)
+    val astConstant1 = PtConstant("c1", DataType.UWORD, 12345.0, Position.DUMMY)
+    val astConstant2 = PtConstant("blockc", DataType.UWORD, 999.0, Position.DUMMY)
+    astBlock1.add(astConstant1)
+    astBlock1.add(astConstant2)
+    val astSub1 = PtSub("sub1", emptyList(), null, Position.DUMMY)
+    val astSub2 = PtSub("sub2", emptyList(), null, Position.DUMMY)
+    val astSub1v1 = PtVariable("v1", DataType.BYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY)
+    val astSub1v2 = PtVariable("v2", DataType.BYTE, ZeropageWish.DONTCARE,null, null, Position.DUMMY)
+    val astSub2v1 = PtVariable("v1", DataType.BYTE, ZeropageWish.DONTCARE,null, null, Position.DUMMY)
+    val astSub2v2 = PtVariable("v2", DataType.BYTE, ZeropageWish.DONTCARE,null, null, Position.DUMMY)
+    astSub1.add(astSub1v1)
+    astSub1.add(astSub1v2)
+    astSub2.add(astSub2v2)
+    astSub2.add(astSub2v2)
+    astBlock1.add(astSub1)
+    astBlock1.add(astSub2)
+    val astBfunc = PtIdentifier("msb", DataType.UBYTE, Position.DUMMY)
+    astBlock1.add(astBfunc)
+    val astBlock2 = PtBlock("block2", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("block2"), Position.DUMMY)
+    val astSub21 = PtSub("sub1", emptyList(), null, Position.DUMMY)
+    val astSub22 = PtSub("sub2", emptyList(), null, Position.DUMMY)
+    val astSub221 = PtSub("subsub", emptyList(), null, Position.DUMMY)
+    val astLabel = PtLabel("label", Position.DUMMY)
+    astSub221.add(astLabel)
+    astSub22.add(astSub221)
+    astBlock2.add(astSub21)
+    astBlock2.add(astSub22)
+    astProgram.add(astBlock1)
+    astProgram.add(astBlock2)
+
+    // now hook up the SymbolTable on that AST
+    val st = SymbolTable(astProgram)
+    val block1 = StNode("block1", StNodeType.BLOCK, astBlock1)
+    val sub11 = StNode("sub1", StNodeType.SUBROUTINE, astSub1)
+    val sub12 = StNode("sub2", StNodeType.SUBROUTINE, astSub2)
     block1.add(sub11)
     block1.add(sub12)
-    block1.add(StConstant("c1", DataType.UWORD, 12345.0, Position.DUMMY))
-    block1.add(StConstant("blockc", DataType.UWORD, 999.0, Position.DUMMY))
-    sub11.add(StStaticVariable("v1", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
-    sub11.add(StStaticVariable("v2", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
-    sub12.add(StStaticVariable("v1", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
-    sub12.add(StStaticVariable("v2", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, Position.DUMMY))
+    block1.add(StConstant("c1", DataType.UWORD, 12345.0, astConstant1))
+    block1.add(StConstant("blockc", DataType.UWORD, 999.0, astConstant2))
+    sub11.add(StStaticVariable("v1", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, astSub1v1))
+    sub11.add(StStaticVariable("v2", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, astSub1v2))
+    sub12.add(StStaticVariable("v1", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, astSub2v1))
+    sub12.add(StStaticVariable("v2", DataType.BYTE, true, null, null, null, null, ZeropageWish.DONTCARE, astSub2v2))
 
-    val block2 = StNode("block2", StNodeType.BLOCK, Position.DUMMY)
-    val sub21 = StNode("sub1", StNodeType.SUBROUTINE, Position.DUMMY)
-    val sub22 = StNode("sub2", StNodeType.SUBROUTINE, Position.DUMMY)
+    val block2 = StNode("block2", StNodeType.BLOCK, astBlock2)
+    val sub21 = StNode("sub1", StNodeType.SUBROUTINE, astSub21)
+    val sub22 = StNode("sub2", StNodeType.SUBROUTINE, astSub22)
     block2.add(sub21)
     block2.add(sub22)
-    val sub221 = StNode("subsub", StNodeType.SUBROUTINE, Position.DUMMY)
-    sub221.add(StNode("label", StNodeType.LABEL, Position.DUMMY))
+    val sub221 = StNode("subsub", StNodeType.SUBROUTINE, astSub221)
+    sub221.add(StNode("label", StNodeType.LABEL, astLabel))
     sub22.add(sub221)
 
-    val builtinfunc = StNode("msb", StNodeType.BUILTINFUNC, Position.DUMMY)
+    val builtinfunc = StNode("msb", StNodeType.BUILTINFUNC, astBfunc)
     st.add(block1)
     st.add(block2)
     st.add(builtinfunc)

compiler/test/TestTypecasts.kt

@@ -49,7 +49,7 @@ class TestTypecasts: FunSpec({
                 }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 4
         val expr = (stmts[3] as Assignment).value as BinaryExpression
         expr.operator shouldBe "and"
@@ -57,7 +57,7 @@ class TestTypecasts: FunSpec({
         (expr.left as IdentifierReference).nameInSource shouldBe listOf("bb2")  // no cast
 
         val result2 = compileText(C64Target(), true, text, writeAssembly = true)!!
-        val stmts2 = result2.program.entrypoint.statements
+        val stmts2 = result2.compilerAst.entrypoint.statements
         stmts2.size shouldBe 6
         val expr2 = (stmts2[4] as Assignment).value as BinaryExpression
         expr2.operator shouldBe "&"
@@ -86,7 +86,7 @@ main {
     }
 }"""
         val result = compileText(C64Target(), true, text, writeAssembly = true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         /*
         ubyte ub1
         ub1 = 1
@@ -120,6 +120,42 @@ main {
         right3.right shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position.DUMMY)
     }
 
+    test("simple logical with bool no typecast") {
+        val text="""
+main  {
+    bool bb
+
+    sub start() {
+        bb = bb and 123
+    }
+}"""
+        val result = compileText(C64Target(), true, text, writeAssembly = true)!!
+        val stmts = result.compilerAst.entrypoint.statements
+        stmts.size shouldBe 2
+        val assignValue = (stmts[0] as Assignment).value as BinaryExpression
+        assignValue.left shouldBe instanceOf<IdentifierReference>()
+        assignValue.operator shouldBe "&"
+        (assignValue.right as NumericLiteral).number shouldBe 1.0
+    }
+
+    test("simple logical with byte instead of bool ok with typecasting") {
+        val text="""
+main  {
+    ubyte ubb
+
+    sub start() {
+        ubb = ubb and 123
+    }
+}"""
+        val result = compileText(C64Target(), true, text, writeAssembly = true)!!
+        val stmts = result.compilerAst.entrypoint.statements
+        stmts.size shouldBe 2
+        val assignValue = (stmts[0] as Assignment).value as BinaryExpression
+        assignValue.left shouldBe instanceOf<BinaryExpression>()        // as a result of the cast to boolean
+        assignValue.operator shouldBe "&"
+        (assignValue.right as NumericLiteral).number shouldBe 1.0
+    }
+
     test("logical with byte instead of bool") {
         val text="""
 %import textio
@@ -329,7 +365,7 @@ main  {
 }
         """
         val result = compileText(C64Target(), true, text, writeAssembly = true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBeGreaterThan 10
     }
 
@@ -542,7 +578,7 @@ main  {
 }
         """
         val result = compileText(C64Target(), true, text, writeAssembly = true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBeGreaterThan 10
     }
 
@@ -561,7 +597,7 @@ main  {
                  }
              }"""
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
         val arraydecl = stmts[0] as VarDecl
         arraydecl.datatype shouldBe DataType.ARRAY_BOOL
@@ -595,7 +631,7 @@ main  {
                  }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 9
         val fcall1 = ((stmts[6] as Assignment).value as IFunctionCall)
         fcall1.args[0] shouldBe NumericLiteral(DataType.UBYTE, 1.0, Position.DUMMY)
@@ -628,7 +664,7 @@ main  {
                 }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBeGreaterThan 10
     }
 
@@ -647,7 +683,7 @@ main  {
                 }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 3
     }
 
@@ -670,7 +706,7 @@ main  {
                 }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 8
         val arg1 = (stmts[2] as IFunctionCall).args.single()
         val arg2 = (stmts[3] as IFunctionCall).args.single()
@@ -707,7 +743,7 @@ main  {
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        result.program.entrypoint.statements.size shouldBe 15
+        result.compilerAst.entrypoint.statements.size shouldBe 15
     }
 
     test("invalid typecasts of numbers") {
@@ -827,7 +863,7 @@ main  {
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         statements.size shouldBeGreaterThan 10
     }
 
@@ -854,7 +890,7 @@ main  {
                 }
             }"""
         val result = compileText(C64Target(), false, text, writeAssembly = true)!!
-        val statements = result.program.entrypoint.statements
+        val statements = result.compilerAst.entrypoint.statements
         statements.size shouldBeGreaterThan 10
     }
 

compiler/test/ast/TestIntermediateAst.kt

@@ -8,7 +8,6 @@ import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.code.target.C64Target
 import prog8.compiler.astprocessing.IntermediateAstMaker
-import prog8.compiler.astprocessing.SymbolTableMaker
 import prog8tests.helpers.compileText
 
 class TestIntermediateAst: FunSpec({
@@ -38,9 +37,8 @@ class TestIntermediateAst: FunSpec({
             loadAddress = target.machine.PROGRAM_LOAD_ADDRESS
         )
         val result = compileText(target, false, text, writeAssembly = false)!!
-        val st = SymbolTableMaker(result.program, options).make()
-        val ast = IntermediateAstMaker(result.program, st, options).transform()
-        ast.name shouldBe result.program.name
+        val ast = IntermediateAstMaker(result.compilerAst, options).transform()
+        ast.name shouldBe result.compilerAst.name
         ast.allBlocks().any() shouldBe true
         val entry = ast.entrypoint() ?: fail("no main.start() found")
         entry.children.size shouldBe 5
@@ -59,18 +57,16 @@ class TestIntermediateAst: FunSpec({
         ccdecl.name shouldBe "cc"
         ccdecl.scopedName shouldBe "main.start.cc"
         ccdecl.type shouldBe DataType.UBYTE
-        val arraydecl = entry.children[1] as PtVariable
+        val arraydecl = entry.children[1] as IPtVariable
         arraydecl.name shouldBe "array"
         arraydecl.type shouldBe DataType.ARRAY_UB
 
-        val containmentCast = (entry.children[3] as PtAssignment).value as PtTypeCast
-        containmentCast.type shouldBe DataType.UBYTE
-        val containment = containmentCast.value as PtContainmentCheck
+        val containment = (entry.children[3] as PtAssignment).value as PtContainmentCheck
         (containment.element as PtNumber).number shouldBe 11.0
         val fcall = (entry.children[4] as PtAssignment).value as PtFunctionCall
         fcall.void shouldBe false
         fcall.type shouldBe DataType.UBYTE
-        ast.print()
+        printAst(ast, ::println)
     }
 
 })

compiler/test/ast/TestProg8Parser.kt

@@ -862,7 +862,7 @@ class TestProg8Parser: FunSpec( {
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val start = result.program.entrypoint
+        val start = result.compilerAst.entrypoint
         val string = (start.statements[0] as VarDecl).value as StringLiteral
         withClue("x-escapes are hacked to range 0x8000-0x80ff") {
             string.value[0].code shouldBe 0x8000
@@ -901,7 +901,7 @@ class TestProg8Parser: FunSpec( {
             }
         """
         val result = compileText(C64Target(), false, text, writeAssembly = false)!!
-        val start = result.program.entrypoint
+        val start = result.compilerAst.entrypoint
         val containmentChecks = start.statements.takeLast(4)
         (containmentChecks[0] as IfElse).condition shouldBe instanceOf<ContainmentCheck>()
         (containmentChecks[1] as IfElse).condition shouldBe instanceOf<ContainmentCheck>()
@@ -942,7 +942,7 @@ class TestProg8Parser: FunSpec( {
             }
         """
         val result = compileText(C64Target(),  false, text, writeAssembly = false)!!
-        val stmt = result.program.entrypoint.statements
+        val stmt = result.compilerAst.entrypoint.statements
         stmt.size shouldBe 12
         val var1 = stmt[0] as VarDecl
         var1.sharedWithAsm shouldBe true

compiler/test/ast/TestVarious.kt

@@ -85,7 +85,7 @@ main {
             }
         }"""
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
     }
 
@@ -101,7 +101,7 @@ main {
             }
         }"""
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=true)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 6
         val name1 = stmts[0] as VarDecl
         val rept1 = stmts[1] as VarDecl
@@ -111,8 +111,8 @@ main {
         val rept2strcopy = stmts[4] as IFunctionCall
         val name2 = name2strcopy.args.first() as IdentifierReference
         val rept2 = rept2strcopy.args.first() as IdentifierReference
-        (name2.targetVarDecl(result.program)!!.value as StringLiteral).value shouldBe "xx1xx2"
-        (rept2.targetVarDecl(result.program)!!.value as StringLiteral).value shouldBe "xyzxyzxyzxyz"
+        (name2.targetVarDecl(result.compilerAst)!!.value as StringLiteral).value shouldBe "xx1xx2"
+        (rept2.targetVarDecl(result.compilerAst)!!.value as StringLiteral).value shouldBe "xyzxyzxyzxyz"
     }
 
     test("pointervariable indexing allowed with >255") {
@@ -144,15 +144,15 @@ main {
     }
 }"""
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 7
         val assign1expr = (stmts[3] as Assignment).value as BinaryExpression
         val assign2expr = (stmts[5] as Assignment).value as BinaryExpression
         assign1expr.operator shouldBe "<<"
-        val leftval1 = assign1expr.left.constValue(result.program)!!
+        val leftval1 = assign1expr.left.constValue(result.compilerAst)!!
         leftval1.type shouldBe DataType.UWORD
         leftval1.number shouldBe 1.0
-        val leftval2 = assign2expr.left.constValue(result.program)!!
+        val leftval2 = assign2expr.left.constValue(result.compilerAst)!!
         leftval2.type shouldBe DataType.UWORD
         leftval2.number shouldBe 1.0
     }
@@ -175,7 +175,7 @@ main {
     }
 }"""
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 9
     }
 
@@ -190,7 +190,7 @@ main {
 }
 """
         val result = compileText(C64Target(), optimize=false, src, writeAssembly=false)!!
-        val stmts = result.program.entrypoint.statements
+        val stmts = result.compilerAst.entrypoint.statements
         stmts.size shouldBe 3
         val value1 = (stmts[1] as Assignment).value as BinaryExpression
         val value2 = (stmts[2] as Assignment).value as BinaryExpression

compiler/test/codegeneration/TestArrayInplaceAssign.kt

@@ -56,8 +56,7 @@ main {
         compileText(VMTarget(), false, text, writeAssembly = true) shouldNotBe null
     }
 
-    // TODO implement this in 6502 codegen and re-enable test
-    xtest("array in-place negation (float type) 6502 target") {
+    test("array in-place negation (float type) 6502 target") {
         val text = """
 %import floats
 

compiler/test/codegeneration/TestAsmGenSymbols.kt

@@ -9,12 +9,16 @@ import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
+import prog8.code.SymbolTableMaker
+import prog8.code.ast.PtAddressOf
+import prog8.code.ast.PtAssignment
+import prog8.code.ast.PtIdentifier
+import prog8.code.ast.PtProgram
 import prog8.code.core.*
 import prog8.code.target.C64Target
 import prog8.code.target.VMTarget
-import prog8.code.target.c64.C64Zeropage
-import prog8.codegen.cpu6502.AsmGen
-import prog8.compiler.astprocessing.SymbolTableMaker
+import prog8.codegen.cpu6502.AsmGen6502Internal
+import prog8.compiler.astprocessing.IntermediateAstMaker
 import prog8tests.helpers.*
 
 class TestAsmGenSymbols: StringSpec({
@@ -42,8 +46,8 @@ class TestAsmGenSymbols: StringSpec({
     }
 
          */
-        val varInSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "localvar", NumericLiteral.optimalInteger(1234, Position.DUMMY), false, false, null, Position.DUMMY)
-        val var2InSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "tgt", null, false, false, null, Position.DUMMY)
+        val varInSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "localvar", NumericLiteral.optimalInteger(1234, Position.DUMMY), false, false, Position.DUMMY)
+        val var2InSub = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "tgt", null, false, false, Position.DUMMY)
         val labelInSub = Label("locallabel", Position.DUMMY)
 
         val tgt = AssignTarget(IdentifierReference(listOf("tgt"), Position.DUMMY), null, null, Position.DUMMY)
@@ -59,7 +63,7 @@ class TestAsmGenSymbols: StringSpec({
         val statements = mutableListOf(varInSub, var2InSub, labelInSub, assign1, assign2, assign3, assign4, assign5, assign6, assign7, assign8)
         val subroutine = Subroutine("start", mutableListOf(), emptyList(), emptyList(), emptyList(), emptySet(), null, false, false, statements, Position.DUMMY)
         val labelInBlock = Label("label_outside", Position.DUMMY)
-        val varInBlock = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "var_outside", null, false, false, null, Position.DUMMY)
+        val varInBlock = VarDecl(VarDeclType.VAR, VarDeclOrigin.USERCODE, DataType.UWORD, ZeropageWish.DONTCARE, null, "var_outside", null, false, false, Position.DUMMY)
         val block = Block("main", null, mutableListOf(labelInBlock, varInBlock, subroutine), false, Position.DUMMY)
 
         val module = Module(mutableListOf(block), Position.DUMMY, SourceCode.Generated("test"))
@@ -68,17 +72,17 @@ class TestAsmGenSymbols: StringSpec({
         return program
     }
 
-    fun createTestAsmGen(program: Program): AsmGen {
+    fun createTestAsmGen6502(program: Program): AsmGen6502Internal {
         val errors = ErrorReporterForTests()
         val options = CompilationOptions(OutputType.RAW, CbmPrgLauncherType.NONE, ZeropageType.FULL, emptyList(), false, true, C64Target(), 999u)
-        options.compTarget.machine.zeropage = C64Zeropage(options)
-        val st = SymbolTableMaker(program, options).make()
-        return AsmGen(program, st, options, errors)
+        val ptProgram = IntermediateAstMaker(program, options).transform()
+        val st = SymbolTableMaker(ptProgram, options).make()
+        return AsmGen6502Internal(ptProgram, st, options, errors)
     }
 
     "symbol and variable names from strings" {
         val program = createTestProgram()
-        val asmgen = createTestAsmGen(program)
+        val asmgen = createTestAsmGen6502(program)
         asmgen.asmSymbolName("name") shouldBe "name"
         asmgen.asmSymbolName("name") shouldBe "name"
         asmgen.asmSymbolName("<name>") shouldBe "prog8_name"
@@ -91,40 +95,40 @@ class TestAsmGenSymbols: StringSpec({
 
     "symbol and variable names from variable identifiers" {
         val program = createTestProgram()
-        val asmgen = createTestAsmGen(program)
-        val sub = program.entrypoint
+        val asmgen = createTestAsmGen6502(program)
+        val sub = asmgen.program.entrypoint()!!
 
-        val localvarIdent = sub.statements.asSequence().filterIsInstance<Assignment>().first { it.value is IdentifierReference }.value as IdentifierReference
+        val localvarIdent = sub.children.asSequence().filterIsInstance<PtAssignment>().first { it.value is PtIdentifier }.value as PtIdentifier
         asmgen.asmSymbolName(localvarIdent) shouldBe "localvar"
         asmgen.asmVariableName(localvarIdent) shouldBe "localvar"
-        val localvarIdentScoped = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("main", "start", "localvar") }.value as AddressOf).identifier
-        asmgen.asmSymbolName(localvarIdentScoped) shouldBe "main.start.localvar"
-        asmgen.asmVariableName(localvarIdentScoped) shouldBe "main.start.localvar"
+        val localvarIdentScoped = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.start.localvar" }.value as PtAddressOf).identifier
+        asmgen.asmSymbolName(localvarIdentScoped) shouldBe "localvar"
+        asmgen.asmVariableName(localvarIdentScoped) shouldBe "localvar"
 
-        val scopedVarIdent = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("var_outside") }.value as AddressOf).identifier
-        asmgen.asmSymbolName(scopedVarIdent) shouldBe "var_outside"
-        asmgen.asmVariableName(scopedVarIdent) shouldBe "var_outside"
-        val scopedVarIdentScoped = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("main", "var_outside") }.value as AddressOf).identifier
+        val scopedVarIdent = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.var_outside" }.value as PtAddressOf).identifier
+        asmgen.asmSymbolName(scopedVarIdent) shouldBe "main.var_outside"
+        asmgen.asmVariableName(scopedVarIdent) shouldBe "main.var_outside"
+        val scopedVarIdentScoped = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.var_outside" }.value as PtAddressOf).identifier
         asmgen.asmSymbolName(scopedVarIdentScoped) shouldBe "main.var_outside"
         asmgen.asmVariableName(scopedVarIdentScoped) shouldBe "main.var_outside"
     }
 
     "symbol and variable names from label identifiers" {
         val program = createTestProgram()
-        val asmgen = createTestAsmGen(program)
-        val sub = program.entrypoint
+        val asmgen = createTestAsmGen6502(program)
+        val sub = asmgen.program.entrypoint()!!
 
-        val localLabelIdent = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("locallabel") }.value as AddressOf).identifier
+        val localLabelIdent = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.start.locallabel" }.value as PtAddressOf).identifier
         asmgen.asmSymbolName(localLabelIdent) shouldBe "locallabel"
         asmgen.asmVariableName(localLabelIdent) shouldBe "locallabel"
-        val localLabelIdentScoped = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("main","start","locallabel") }.value as AddressOf).identifier
-        asmgen.asmSymbolName(localLabelIdentScoped) shouldBe "main.start.locallabel"
-        asmgen.asmVariableName(localLabelIdentScoped) shouldBe "main.start.locallabel"
+        val localLabelIdentScoped = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.start.locallabel" }.value as PtAddressOf).identifier
+        asmgen.asmSymbolName(localLabelIdentScoped) shouldBe "locallabel"
+        asmgen.asmVariableName(localLabelIdentScoped) shouldBe "locallabel"
 
-        val scopedLabelIdent = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("label_outside") }.value as AddressOf).identifier
-        asmgen.asmSymbolName(scopedLabelIdent) shouldBe "label_outside"
-        asmgen.asmVariableName(scopedLabelIdent) shouldBe "label_outside"
-        val scopedLabelIdentScoped = (sub.statements.asSequence().filterIsInstance<Assignment>().first { (it.value as? AddressOf)?.identifier?.nameInSource==listOf("main","label_outside") }.value as AddressOf).identifier
+        val scopedLabelIdent = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.label_outside" }.value as PtAddressOf).identifier
+        asmgen.asmSymbolName(scopedLabelIdent) shouldBe "main.label_outside"
+        asmgen.asmVariableName(scopedLabelIdent) shouldBe "main.label_outside"
+        val scopedLabelIdentScoped = (sub.children.asSequence().filterIsInstance<PtAssignment>().first { (it.value as? PtAddressOf)?.identifier?.name=="main.label_outside" }.value as PtAddressOf).identifier
         asmgen.asmSymbolName(scopedLabelIdentScoped) shouldBe "main.label_outside"
         asmgen.asmVariableName(scopedLabelIdentScoped) shouldBe "main.label_outside"
     }
@@ -140,15 +144,15 @@ main {
         prog8_lib.P8ZP_SCRATCH_W2 = 1
          */
         val program = createTestProgram()
-        val asmgen = createTestAsmGen(program)
+        val asmgen = createTestAsmGen6502(program)
         asmgen.asmSymbolName("prog8_lib.P8ZP_SCRATCH_REG") shouldBe "P8ZP_SCRATCH_REG"
         asmgen.asmSymbolName("prog8_lib.P8ZP_SCRATCH_W2") shouldBe "P8ZP_SCRATCH_W2"
         asmgen.asmSymbolName(listOf("prog8_lib","P8ZP_SCRATCH_REG")) shouldBe "P8ZP_SCRATCH_REG"
         asmgen.asmSymbolName(listOf("prog8_lib","P8ZP_SCRATCH_W2")) shouldBe "P8ZP_SCRATCH_W2"
-        val id1 = IdentifierReference(listOf("prog8_lib","P8ZP_SCRATCH_REG"), Position.DUMMY)
-        id1.linkParents(program.toplevelModule)
-        val id2 = IdentifierReference(listOf("prog8_lib","P8ZP_SCRATCH_W2"), Position.DUMMY)
-        id2.linkParents(program.toplevelModule)
+        val id1 = PtIdentifier("prog8_lib.P8ZP_SCRATCH_REG", DataType.UBYTE, Position.DUMMY)
+        val id2 = PtIdentifier("prog8_lib.P8ZP_SCRATCH_W2", DataType.UWORD, Position.DUMMY)
+        id1.parent = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        id2.parent = PtProgram("test", DummyMemsizer, DummyStringEncoder)
         asmgen.asmSymbolName(id1) shouldBe "P8ZP_SCRATCH_REG"
         asmgen.asmSymbolName(id2) shouldBe "P8ZP_SCRATCH_W2"
     }

compiler/test/codegeneration/TestVarious.kt

@@ -1,7 +1,15 @@
 package prog8tests.codegeneration
 
 import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.ints.shouldBeGreaterThan
+import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import io.kotest.matchers.string.shouldStartWith
+import io.kotest.matchers.types.instanceOf
+import prog8.code.ast.PtArrayIndexer
+import prog8.code.ast.PtAssignment
+import prog8.code.ast.PtVariable
+import prog8.code.core.DataType
 import prog8.code.target.C64Target
 import prog8tests.helpers.compileText
 
@@ -11,7 +19,8 @@ class TestVarious: FunSpec({
 main {
     sub start() {
         ubyte[3] values
-        func(33 + (22 in values))
+        func(22 in values)
+        ubyte @shared qq = 22 in values
     }
     sub func(ubyte arg) {
         arg++
@@ -19,4 +28,67 @@ main {
 }"""
         compileText(C64Target(), false, text, writeAssembly = true) shouldNotBe null
     }
+
+    test("nested scoping") {
+        val text="""
+main {
+    sub start() {
+        testscope.duplicate()
+        cx16.r0L = testscope.duplicate2()
+    }
+}
+
+testscope {
+
+    sub sub1() {
+        ubyte @shared duplicate
+        ubyte @shared duplicate2
+    }
+
+    sub duplicate() {
+        ; do nothing
+    }
+
+    sub duplicate2() -> ubyte {
+        return cx16.r0L
+    }
+}"""
+        compileText(C64Target(), false, text, writeAssembly = true) shouldNotBe null
+    }
+
+    test("word array indexing") {
+        val text="""
+main {
+    sub start() {
+        uword[3] seed
+        cx16.r0 = seed[0] + seed[1] + seed[2]
+    }
+}"""
+        compileText(C64Target(), false, text, writeAssembly = true) shouldNotBe null
+    }
+
+
+    test("ast result from compileText") {
+        val text="""
+main {
+    sub start() {
+        uword[3] seed
+        cx16.r0 = seed[0] + seed[1] + seed[2]
+    }
+}"""
+        val result = compileText(C64Target(), false, text, writeAssembly = true)!!
+        result.compilerAst.name shouldStartWith  "on_the_fly"
+        result.codegenAst!!.name shouldBe result.compilerAst.name
+        result.codegenAst!!.children.size shouldBeGreaterThan 2
+        val start = result.codegenAst!!.entrypoint()!!
+        start.name shouldBe "start"
+        start.children.size shouldBeGreaterThan 2
+        val seed = start.children[0] as PtVariable
+        seed.name shouldBe "seed"
+        seed.value shouldBe null
+        seed.type shouldBe DataType.ARRAY_UW
+        val assign = start.children[1] as PtAssignment
+        assign.target.identifier!!.name shouldBe "cx16.r0"
+        assign.value shouldBe instanceOf<PtArrayIndexer>()
+    }
 })

compiler/test/helpers/Dummies.kt

@@ -5,6 +5,7 @@ import prog8.ast.expressions.Expression
 import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteral
 import prog8.code.core.*
+import prog8.code.target.virtual.VirtualMachineDefinition
 
 
 internal object DummyFunctions : IBuiltinFunctions {
@@ -29,7 +30,7 @@ internal object DummyStringEncoder : IStringEncoding {
         return emptyList()
     }
 
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
         return ""
     }
 }
@@ -37,15 +38,14 @@ internal object DummyStringEncoder : IStringEncoding {
 internal object AsciiStringEncoder : IStringEncoding {
     override fun encodeString(str: String, encoding: Encoding): List<UByte> = str.map { it.code.toUByte() }
 
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
         return bytes.joinToString()
     }
 }
 
 internal object DummyCompilationTarget : ICompilationTarget {
     override val name: String = "dummy"
-    override val machine: IMachineDefinition
-        get() = throw NotImplementedError("dummy")
+    override val machine: IMachineDefinition = VirtualMachineDefinition()  // not really true but I don't want to implement a full dummy machinedef
     override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES, Encoding.ISO)
     override val defaultEncoding = Encoding.PETSCII
 
@@ -53,7 +53,7 @@ internal object DummyCompilationTarget : ICompilationTarget {
         throw NotImplementedError("dummy")
     }
 
-    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+    override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String {
         throw NotImplementedError("dummy")
     }
 

compiler/test/vm/TestCompilerVirtual.kt

@@ -35,7 +35,7 @@ main {
 }"""
         val target = VMTarget()
         val result = compileText(target, true, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runProgram(virtfile.readText())
     }
 
@@ -57,7 +57,7 @@ main {
         compileText(othertarget, true, src, writeAssembly = true) shouldNotBe null
         val target = VMTarget()
         val result = compileText(target, true, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runProgram(virtfile.readText())
     }
 
@@ -75,11 +75,11 @@ main {
 }"""
         val target = VMTarget()
         var result = compileText(target, false, src, writeAssembly = true)!!
-        var virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        var virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runProgram(virtfile.readText())
 
         result = compileText(target, true, src, writeAssembly = true)!!
-        virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runProgram(virtfile.readText())
     }
 
@@ -169,7 +169,7 @@ skipLABEL:
         compileText(othertarget, true, src, writeAssembly = true) shouldNotBe null
         val target = VMTarget()
         val result = compileText(target, true, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runAndTestProgram(virtfile.readText()) { vm ->
             vm.memory.getUB(0) shouldBe 42u
             vm.memory.getUB(3) shouldBe 66u
@@ -189,10 +189,10 @@ main {
 }"""
         val target = VMTarget()
         val result = compileText(target, true, src, writeAssembly = true)!!
-        val start = result.program.entrypoint
+        val start = result.compilerAst.entrypoint
         start.statements.size shouldBe 9
         ((start.statements[1] as Assignment).value as BuiltinFunctionCall).name shouldBe "memory"
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runAndTestProgram(virtfile.readText()) { vm ->
             vm.memory.getUB(2) shouldBe 42u
             vm.memory.getUB(3) shouldBe 43u
@@ -213,7 +213,7 @@ main {
 
         val target = VMTarget()
         val result = compileText(target, false, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runAndTestProgram(virtfile.readText()) { vm ->
             vm.stepCount shouldBe 49
         }
@@ -283,7 +283,7 @@ main {
 
         val target = VMTarget()
         val result = compileText(target, false, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         val exc = shouldThrow<Exception> {
             VmRunner().runProgram(virtfile.readText())
         }
@@ -304,7 +304,7 @@ main {
 
         val target = VMTarget()
         val result = compileText(target, false, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         VmRunner().runProgram(virtfile.readText())
     }
 
@@ -329,7 +329,7 @@ mylabel:
 
         val target = VMTarget()
         val result = compileText(target, false, src, writeAssembly = true)!!
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         val exc = shouldThrow<Exception> {
             VmRunner().runProgram(virtfile.readText())
         }
@@ -381,8 +381,8 @@ main {
     }
 }"""
         val result = compileText(VMTarget(), true, src, writeAssembly = true)!!
-        result.program.entrypoint.statements.size shouldBe 9
-        val virtfile = result.compilationOptions.outputDir.resolve(result.program.name + ".p8ir")
+        result.compilerAst.entrypoint.statements.size shouldBe 9
+        val virtfile = result.compilationOptions.outputDir.resolve(result.compilerAst.name + ".p8ir")
         val irProgram = IRFileReader().read(virtfile)
         val start = irProgram.blocks[0].children[0] as IRSubroutine
         val instructions = start.chunks.flatMap { c->c.instructions }

compilerAst/src/prog8/ast/AstToSourceTextConverter.kt

@@ -6,6 +6,14 @@ import prog8.ast.walk.IAstVisitor
 import prog8.code.core.*
 
 
+fun printProgram(program: Program) {
+    println()
+    val printer = AstToSourceTextConverter(::print, program)
+    printer.visit(program)
+    println()
+}
+
+
 /**
  * Produces Prog8 source text from a [Program] (AST node),
  * passing it as a String to the specified receiver function.

compilerAst/src/prog8/ast/Extensions.kt

@@ -40,7 +40,7 @@ fun Program.getTempVar(dt: DataType, altNames: Boolean=false): Pair<List<String>
     // add new temp variable to the ast directly (we can do this here because we're not iterating inside those container blocks)
     val decl = VarDecl(
         VarDeclType.VAR, VarDeclOrigin.AUTOGENERATED, dt, ZeropageWish.DONTCARE,
-        null, tmpvarName[1], null, isArray = false, sharedWithAsm = false, subroutineParameter = null, position = Position.DUMMY
+        null, tmpvarName[1], null, isArray = false, sharedWithAsm = false, position = Position.DUMMY
     )
     block.statements.add(decl)
     decl.linkParents(block)

compilerAst/src/prog8/ast/Program.kt

@@ -85,7 +85,7 @@ class Program(val name: String,
             val varName = "string_${internedStringsBlock.statements.size}"
             val decl = VarDecl(
                 VarDeclType.VAR, VarDeclOrigin.STRINGLITERAL, DataType.STR, ZeropageWish.NOT_IN_ZEROPAGE, null, varName, string,
-                isArray = false, sharedWithAsm = false, subroutineParameter = null, position = string.position
+                isArray = false, sharedWithAsm = false, position = string.position
             )
             internedStringsBlock.statements.add(decl)
             decl.linkParents(internedStringsBlock)
@@ -147,7 +147,7 @@ class Program(val name: String,
 
     fun makeLabel(postfix: String): String {
         generatedLabelSequenceNumber++
-        return "${generatedLabelPrefix}${generatedLabelSequenceNumber}_$postfix"
+        return "prog8_label_${generatedLabelSequenceNumber}_$postfix"
     }
 
     fun makeLabel(postfix: String, position: Position): Label {
@@ -160,6 +160,3 @@ class Program(val name: String,
         return Jump(null, ident, null, label.position)
     }
 }
-
-
-const val generatedLabelPrefix = "prog8_label_"

compilerAst/src/prog8/ast/antlr/Antlr2Kotlin.kt

@@ -280,12 +280,19 @@ private fun Prog8ANTLRParser.LabeldefContext.toAst(): Statement =
 private fun Prog8ANTLRParser.SubroutineContext.toAst() : Subroutine {
     // non-asm subroutine
     val returntype = sub_return_part()?.datatype()?.toAst()
-    return Subroutine(identifier().text,
+    return Subroutine(
+        identifier().text,
         sub_params()?.toAst()?.toMutableList() ?: mutableListOf(),
         if (returntype == null) emptyList() else listOf(returntype),
-            statement_block()?.toAst() ?: mutableListOf(),
-            false,
-            toPosition())
+        emptyList(),
+        emptyList(),
+        emptySet(),
+        asmAddress = null,
+        isAsmSubroutine = false,
+        inline = false,
+        statements = statement_block()?.toAst() ?: mutableListOf(),
+        position = toPosition()
+    )
 }
 
 private fun Prog8ANTLRParser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
@@ -600,7 +607,6 @@ private fun Prog8ANTLRParser.VardeclContext.toAst(type: VarDeclType, value: Expr
             value,
             ARRAYSIG() != null || arrayindex() != null,
             shared,
-            null,
             toPosition()
     )
 }

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

@@ -10,7 +10,6 @@ import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstVisitor
 import prog8.code.core.*
-import prog8.compiler.BuiltinFunctions
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.floor

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

@@ -14,7 +14,7 @@ object InferredTypes {
         fun getOr(default: DataType) = if(isUnknown || isVoid) default else datatype!!
         fun getOrElse(transform: (InferredType) -> DataType): DataType =
             if(isUnknown || isVoid) transform(this) else datatype!!
-        infix fun istype(type: DataType): Boolean = if(isUnknown || isVoid) false else this.datatype==type
+        infix fun istype(type: DataType): Boolean = if(isUnknown || isVoid) false else this.datatype==type      // strict equality if known
         infix fun isnot(type: DataType): Boolean = if(isUnknown || isVoid) true else this.datatype!=type
         fun oneOf(vararg types: DataType) = if(isUnknown || isVoid) false else this.datatype in types
 

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

@@ -190,7 +190,6 @@ class VarDecl(val type: VarDeclType,
               var value: Expression?,
               val isArray: Boolean,
               val sharedWithAsm: Boolean,
-              val subroutineParameter: SubroutineParameter?,
               override val position: Position) : Statement(), INamedStatement {
     override lateinit var parent: Node
     var allowInitializeWithZero = true
@@ -204,7 +203,6 @@ class VarDecl(val type: VarDeclType,
             return VarDecl(VarDeclType.VAR, VarDeclOrigin.SUBROUTINEPARAM, param.type, ZeropageWish.DONTCARE, null, param.name, null,
                 isArray = false,
                 sharedWithAsm = false,
-                subroutineParameter = param,
                 position = param.position
             )
         }
@@ -215,7 +213,7 @@ class VarDecl(val type: VarDeclType,
             val declaredType = ArrayToElementTypes.getValue(arrayDt)
             val arraysize = ArrayIndex.forArray(array)
             return VarDecl(VarDeclType.VAR, VarDeclOrigin.ARRAYLITERAL, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, array,
-                    isArray = true, sharedWithAsm = false, subroutineParameter = null, position = array.position)
+                    isArray = true, sharedWithAsm = false, position = array.position)
         }
     }
 
@@ -262,14 +260,14 @@ class VarDecl(val type: VarDeclType,
 
     override fun copy(): VarDecl {
         val copy = VarDecl(type, origin, declaredDatatype, zeropage, arraysize?.copy(), name, value?.copy(),
-            isArray, sharedWithAsm, subroutineParameter, position)
+            isArray, sharedWithAsm, position)
         copy.allowInitializeWithZero = this.allowInitializeWithZero
         return copy
     }
 
     fun renamed(newName: String): VarDecl {
         val copy = VarDecl(type, origin, declaredDatatype, zeropage, arraysize, newName, value,
-            isArray, sharedWithAsm, subroutineParameter, position)
+            isArray, sharedWithAsm, position)
         copy.allowInitializeWithZero = this.allowInitializeWithZero
         return copy
     }
@@ -316,10 +314,8 @@ class ArrayIndex(var indexExpr: Expression,
 enum class AssignmentOrigin {
     USERCODE,
     VARINIT,
-    PARAMETERASSIGN,
     OPTIMIZER,
-    BEFOREASMGEN,
-    ASMGEN,
+    ASMGEN
 }
 
 class Assignment(var target: AssignTarget, var value: Expression, var origin: AssignmentOrigin, override val position: Position) : Statement() {
@@ -695,22 +691,6 @@ class Subroutine(override val name: String,
                  override var statements: MutableList<Statement>,
                  override val position: Position) : Statement(), INameScope {
 
-    constructor(name: String, parameters: MutableList<SubroutineParameter>, returntypes: List<DataType>, statements: MutableList<Statement>, inline: Boolean, position: Position)
-            : this(name, parameters, returntypes, emptyList(), determineReturnRegisters(returntypes), emptySet(), null, false, inline, statements, position)
-
-    companion object {
-        private fun determineReturnRegisters(returntypes: List<DataType>): List<RegisterOrStatusflag> {
-            // for non-asm subroutines, determine the return registers based on the type of the return value
-            return when(returntypes.singleOrNull()) {
-                in ByteDatatypes -> listOf(RegisterOrStatusflag(RegisterOrPair.A, null))
-                in WordDatatypes -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null))
-                DataType.FLOAT -> listOf(RegisterOrStatusflag(RegisterOrPair.FAC1, null))
-                null -> emptyList()
-                else -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null))
-            }
-        }
-    }
-
     override lateinit var parent: Node
     override fun copy() = throw NotImplementedError("no support for duplicating a Subroutine")
 
@@ -741,27 +721,11 @@ class Subroutine(override val name: String,
     override fun toString() =
         "Subroutine(name=$name, parameters=$parameters, returntypes=$returntypes, ${statements.size} statements, address=$asmAddress)"
 
-    fun regXasResult() = asmReturnvaluesRegisters.any { it.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-    fun regXasParam() = asmParameterRegisters.any { it.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-    fun shouldSaveX() = CpuRegister.X in asmClobbers || regXasResult() || regXasParam()
-
-    class KeepAresult(val saveOnEntry: Boolean, val saveOnReturn: Boolean)
-
-    fun shouldKeepA(): KeepAresult {
-        // determine if A's value should be kept when preparing for calling the subroutine, and when returning from it
-        if(!isAsmSubroutine)
-            return KeepAresult(saveOnEntry = false, saveOnReturn = false)
-
-        // it seems that we never have to save A when calling? will be loaded correctly after setup.
-        // but on return it depends on wether the routine returns something in A.
-        val saveAonReturn = asmReturnvaluesRegisters.any { it.registerOrPair==RegisterOrPair.A || it.registerOrPair==RegisterOrPair.AY || it.registerOrPair==RegisterOrPair.AX }
-        return KeepAresult(false, saveAonReturn)
-    }
-
     // code to provide the ability to reference asmsub parameters via qualified name:
     private val asmParamsDecls = mutableMapOf<String, VarDecl>()
 
     fun searchParameter(name: String): VarDecl? {
+        // TODO can we get rid of this routine? it makes temporary vardecls...
         val existingDecl = asmParamsDecls[name]
         if(existingDecl!=null)
             return existingDecl

compilerAst/src/prog8/compiler/BuiltinFunctions.kt

@@ -1,256 +0,0 @@
-package prog8.compiler
-
-import prog8.ast.Program
-import prog8.ast.base.AstException
-import prog8.ast.base.FatalAstException
-import prog8.ast.base.SyntaxError
-import prog8.ast.expressions.*
-import prog8.ast.statements.VarDecl
-import prog8.code.core.*
-import kotlin.math.abs
-import kotlin.math.sign
-import kotlin.math.sqrt
-
-
-private typealias ConstExpressionCaller = (args: List<Expression>, position: Position, program: Program) -> NumericLiteral
-
-class ReturnConvention(val dt: DataType?, val reg: RegisterOrPair?, val floatFac1: Boolean)
-class ParamConvention(val dt: DataType, val reg: RegisterOrPair?, val variable: Boolean)
-class CallConvention(val params: List<ParamConvention>, val returns: ReturnConvention) {
-    override fun toString(): String {
-        val paramConvs =  params.mapIndexed { index, it ->
-            when {
-                it.reg!=null -> "$index:${it.reg}"
-                it.variable -> "$index:variable"
-                else -> "$index:???"
-            }
-        }
-        val returnConv =
-            when {
-                returns.reg!=null -> returns.reg.toString()
-                returns.floatFac1 -> "floatFAC1"
-                else -> "<no returnvalue>"
-            }
-        return "CallConvention[" + paramConvs.joinToString() + " ; returns: $returnConv]"
-    }
-}
-
-class FParam(val name: String, val possibleDatatypes: Array<DataType>)
-
-class FSignature(val name: String,
-                 val pure: Boolean,      // does it have side effects?
-                 val parameters: List<FParam>,
-                 val returnType: DataType?,
-                 val constExpressionFunc: ConstExpressionCaller? = null) {
-
-    fun callConvention(actualParamTypes: List<DataType>): CallConvention {
-        val returns: ReturnConvention = when (returnType) {
-            DataType.UBYTE, DataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A, false)
-            DataType.UWORD, DataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY, false)
-            DataType.FLOAT -> ReturnConvention(returnType, null, true)
-            in PassByReferenceDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY, false)
-            null -> ReturnConvention(null, null, false)
-            else -> {
-                // return type depends on arg type
-                when (val paramType = actualParamTypes.first()) {
-                    DataType.UBYTE, DataType.BYTE -> ReturnConvention(paramType, RegisterOrPair.A, false)
-                    DataType.UWORD, DataType.WORD -> ReturnConvention(paramType, RegisterOrPair.AY, false)
-                    DataType.FLOAT -> ReturnConvention(paramType, null, true)
-                    in PassByReferenceDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY, false)
-                    else -> ReturnConvention(paramType, null, false)
-                }
-            }
-        }
-
-        return when {
-            actualParamTypes.isEmpty() -> CallConvention(emptyList(), returns)
-            actualParamTypes.size==1 -> {
-                // one parameter goes via register/registerpair
-                val paramConv = when(val paramType = actualParamTypes[0]) {
-                    DataType.UBYTE, DataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false)
-                    DataType.UWORD, DataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false)
-                    DataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false)
-                    in PassByReferenceDatatypes -> ParamConvention(paramType, RegisterOrPair.AY, false)
-                    else -> ParamConvention(paramType, null, false)
-                }
-                CallConvention(listOf(paramConv), returns)
-            }
-            else -> {
-                // multiple parameters go via variables
-                val paramConvs = actualParamTypes.map { ParamConvention(it, null, true) }
-                CallConvention(paramConvs, returns)
-            }
-        }
-    }
-}
-
-
-private val functionSignatures: List<FSignature> = listOf(
-    // this set of function have no return value and operate in-place:
-    FSignature("rol"         , false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    FSignature("ror"         , false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    FSignature("rol2"        , false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    FSignature("ror2"        , false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    FSignature("sort"        , false, listOf(FParam("array", ArrayDatatypes)), null),
-    FSignature("reverse"     , false, listOf(FParam("array", ArrayDatatypes)), null),
-    // cmp returns a status in the carry flag, but not a proper return value
-    FSignature("cmp"         , false, listOf(FParam("value1", IntegerDatatypesNoBool), FParam("value2", NumericDatatypesNoBool)), null),
-    FSignature("abs"         , true, listOf(FParam("value", IntegerDatatypesNoBool)), DataType.UWORD, ::builtinAbs),
-    FSignature("len"         , true, listOf(FParam("values", IterableDatatypes)), DataType.UWORD, ::builtinLen),
-    // normal functions follow:
-    FSignature("sizeof"      , true, listOf(FParam("object", DataType.values())), DataType.UBYTE, ::builtinSizeof),
-    FSignature("sgn"         , true, listOf(FParam("value", NumericDatatypesNoBool)), DataType.BYTE, ::builtinSgn ),
-    FSignature("sqrt16"      , true, listOf(FParam("value", arrayOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()) } },
-    FSignature("any"         , true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
-    FSignature("all"         , true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
-    FSignature("lsb"         , true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> (x and 255).toDouble() } },
-    FSignature("msb"         , true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> (x ushr 8 and 255).toDouble()} },
-    FSignature("mkword"      , true, listOf(FParam("msb", arrayOf(DataType.UBYTE)), FParam("lsb", arrayOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
-    FSignature("peek"        , true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UBYTE),
-    FSignature("peekw"       , true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
-    FSignature("poke"        , false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
-    FSignature("pokemon"     , false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
-    FSignature("pokew"       , false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UWORD))), null),
-    FSignature("pop"         , false, listOf(FParam("target", ByteDatatypes)), null),
-    FSignature("popw"        , false, listOf(FParam("target", WordDatatypes)), null),
-    FSignature("push"        , false, listOf(FParam("value", ByteDatatypes)), null),
-    FSignature("pushw"       , false, listOf(FParam("value", WordDatatypes)), null),
-    FSignature("rsave"       , false, emptyList(), null),
-    FSignature("rsavex"      , false, emptyList(), null),
-    FSignature("rrestore"    , false, emptyList(), null),
-    FSignature("rrestorex"   , false, emptyList(), null),
-    FSignature("memory"      , true, listOf(FParam("name", arrayOf(DataType.STR)), FParam("size", arrayOf(DataType.UWORD)), FParam("alignment", arrayOf(DataType.UWORD))), DataType.UWORD),
-    FSignature("callfar"     , false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), null),
-    FSignature("callrom"     , false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), null),
-)
-
-val BuiltinFunctions = functionSignatures.associateBy { it.name }
-val InplaceModifyingBuiltinFunctions = setOf("rol", "ror", "rol2", "ror2", "sort", "reverse")
-
-private fun builtinAny(array: List<Double>): Double = if(array.any { it!=0.0 }) 1.0 else 0.0
-
-private fun builtinAll(array: List<Double>): Double = if(array.all { it!=0.0 }) 1.0 else 0.0
-
-fun builtinFunctionReturnType(function: String): InferredTypes.InferredType {
-    if(function in arrayOf("set_carry", "set_irqd", "clear_carry", "clear_irqd"))
-        return InferredTypes.InferredType.void()
-
-    val func = BuiltinFunctions.getValue(function)
-    if(func.returnType==null)
-        return InferredTypes.InferredType.void()
-    return InferredTypes.knownFor(func.returnType)
-}
-
-
-class NotConstArgumentException: AstException("not a const argument to a built-in function")
-class CannotEvaluateException(func:String, msg: String): FatalAstException("cannot evaluate built-in function $func: $msg")
-
-
-private fun oneIntArgOutputInt(args: List<Expression>, position: Position, program: Program, function: (arg: Int)->Double): NumericLiteral {
-    if(args.size!=1)
-        throw SyntaxError("built-in function requires one integer argument", position)
-    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    if(constval.type != DataType.UBYTE && constval.type!= DataType.UWORD)
-        throw SyntaxError("built-in function requires one integer argument", position)
-
-    val integer = constval.number.toInt()
-    return NumericLiteral.optimalInteger(function(integer).toInt(), args[0].position)
-}
-
-private fun collectionArg(args: List<Expression>, position: Position, program: Program, function: (arg: List<Double>)->Double): NumericLiteral {
-    if(args.size!=1)
-        throw SyntaxError("builtin function requires one non-scalar argument", position)
-
-    val array= args[0] as? ArrayLiteral ?: throw NotConstArgumentException()
-    val constElements = array.value.map{it.constValue(program)?.number}
-    if(constElements.contains(null))
-        throw NotConstArgumentException()
-
-    return NumericLiteral.optimalNumeric(function(constElements.mapNotNull { it }), args[0].position)
-}
-
-private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    // 1 arg, type = int, result type= uword
-    if(args.size!=1)
-        throw SyntaxError("abs requires one integer argument", position)
-
-    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    return when (constval.type) {
-        in IntegerDatatypesNoBool -> NumericLiteral.optimalInteger(abs(constval.number.toInt()), args[0].position)
-        else -> throw SyntaxError("abs requires one integer argument", position)
-    }
-}
-
-private fun builtinSizeof(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    // 1 arg, type = anything, result type = ubyte
-    if(args.size!=1)
-        throw SyntaxError("sizeof requires one argument", position)
-    if(args[0] !is IdentifierReference)
-        throw SyntaxError("sizeof argument should be an identifier", position)
-
-    val dt = args[0].inferType(program)
-    if(dt.isKnown) {
-        val target = (args[0] as IdentifierReference).targetStatement(program)
-            ?: throw CannotEvaluateException("sizeof", "no target")
-
-        return when {
-            dt.isArray -> {
-                val length = (target as VarDecl).arraysize!!.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
-                val elementDt = ArrayToElementTypes.getValue(dt.getOr(DataType.UNDEFINED))
-                NumericLiteral.optimalInteger(program.memsizer.memorySize(elementDt) * length, position)
-            }
-            dt istype DataType.STR -> throw SyntaxError("sizeof str is undefined, did you mean len?", position)
-            else -> NumericLiteral(DataType.UBYTE, program.memsizer.memorySize(dt.getOr(DataType.UNDEFINED)).toDouble(), position)
-        }
-    } else {
-        throw SyntaxError("sizeof invalid argument type", position)
-    }
-}
-
-private fun builtinLen(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    // note: in some cases the length is > 255, and then we have to return a UWORD type instead of a UBYTE.
-    if(args.size!=1)
-        throw SyntaxError("len requires one argument", position)
-
-    val directMemVar = ((args[0] as? DirectMemoryRead)?.addressExpression as? IdentifierReference)?.targetVarDecl(program)
-    var arraySize = directMemVar?.arraysize?.constIndex()
-    if(arraySize != null)
-        return NumericLiteral.optimalInteger(arraySize, position)
-    if(args[0] is ArrayLiteral)
-        return NumericLiteral.optimalInteger((args[0] as ArrayLiteral).value.size, position)
-    if(args[0] !is IdentifierReference)
-        throw SyntaxError("len argument should be an identifier", position)
-    val target = (args[0] as IdentifierReference).targetVarDecl(program)
-        ?: throw CannotEvaluateException("len", "no target vardecl")
-
-    return when(target.datatype) {
-        in ArrayDatatypes -> {
-            arraySize = target.arraysize?.constIndex()
-            if(arraySize==null)
-                throw CannotEvaluateException("len", "arraysize unknown")
-            NumericLiteral.optimalInteger(arraySize, args[0].position)
-        }
-        DataType.STR -> {
-            val refLv = target.value as? StringLiteral ?: throw CannotEvaluateException("len", "stringsize unknown")
-            NumericLiteral.optimalInteger(refLv.value.length, args[0].position)
-        }
-        in NumericDatatypes -> throw SyntaxError("cannot use len on numeric value, did you mean sizeof?", args[0].position)
-        else -> throw InternalCompilerException("weird datatype")
-    }
-}
-
-private fun builtinMkword(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    if (args.size != 2)
-        throw SyntaxError("mkword requires msb and lsb arguments", position)
-    val constMsb = args[0].constValue(program) ?: throw NotConstArgumentException()
-    val constLsb = args[1].constValue(program) ?: throw NotConstArgumentException()
-    val result = (constMsb.number.toInt() shl 8) or constLsb.number.toInt()
-    return NumericLiteral(DataType.UWORD, result.toDouble(), position)
-}
-
-private fun builtinSgn(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    if (args.size != 1)
-        throw SyntaxError("sgn requires one argument", position)
-    val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    return NumericLiteral(DataType.BYTE, constval.number.sign, position)
-}

compilerAst/src/prog8/compiler/CallGraph.kt

@@ -3,7 +3,6 @@ package prog8.compiler
 import prog8.ast.Module
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.FunctionCallExpression
 import prog8.ast.expressions.IdentifierReference
@@ -12,7 +11,7 @@ import prog8.ast.walk.IAstVisitor
 import prog8.code.core.IErrorReporter
 
 
-class CallGraph(private val program: Program, private val allowMissingIdentifierTargetVarDecls: Boolean=false) : IAstVisitor {
+class CallGraph(private val program: Program) : IAstVisitor {
 
     val imports = mutableMapOf<Module, Set<Module>>().withDefault { setOf() }
     val importedBy = mutableMapOf<Module, Set<Module>>().withDefault { setOf() }
@@ -99,15 +98,8 @@ class CallGraph(private val program: Program, private val allowMissingIdentifier
 
     override fun visit(identifier: IdentifierReference) {
         val target = identifier.targetStatement(program)
-        if(allowMissingIdentifierTargetVarDecls) {
         if(target!=null)
             allIdentifiersAndTargets[identifier] = target
-        } else {
-            if(target==null)
-                throw FatalAstException("missing target stmt for $identifier")
-            else
-                allIdentifiersAndTargets[identifier] = target
-        }
     }
 
     override fun visit(inlineAssembly: InlineAssembly) {

docs/source/prog8compiler.svg

@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg version="1.2" width="215.9mm" height="235mm" viewBox="0 0 21590 23500" preserveAspectRatio="xMidYMid" fill-rule="evenodd" stroke-width="28.222" stroke-linejoin="round" xmlns="http://www.w3.org/2000/svg" xmlns:ooo="http://xml.openoffice.org/svg/export" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:presentation="http://sun.com/xmlns/staroffice/presentation" xmlns:smil="http://www.w3.org/2001/SMIL20/" xmlns:anim="urn:oasis:names:tc:opendocument:xmlns:animation:1.0" xml:space="preserve">
+<svg version="1.2" width="215.9mm" height="235mm" viewBox="0 0 21590 23500" preserveAspectRatio="xMidYMid"
+     fill-rule="evenodd" stroke-width="28.222" stroke-linejoin="round" xmlns="http://www.w3.org/2000/svg"
+     xmlns:ooo="http://xml.openoffice.org/svg/export"
+     xml:space="preserve">
  <defs class="ClipPathGroup">
   <clipPath id="presentation_clip_path" clipPathUnits="userSpaceOnUse">
    <rect x="0" y="0" width="21590" height="23500"/>
@@ -96,6 +99,7 @@
    <font-face font-family="Liberation Serif embedded" units-per-em="2048" font-weight="normal" font-style="italic" ascent="1826" descent="450"/>
    <missing-glyph horiz-adv-x="2048" d="M 0,0 L 2047,0 2047,2047 0,2047 0,0 Z"/>
    <glyph unicode="y" horiz-adv-x="1112" d="M 52,940 L 308,940 453,208 688,614 C 731,689 752,753 752,807 752,832 745,851 731,866 717,881 702,890 686,895 L 694,940 884,940 C 901,925 910,904 910,877 910,824 882,751 827,657 L 431,-10 C 355,-139 295,-231 251,-285 206,-339 162,-379 119,-404 76,-429 29,-442 -22,-442 -76,-442 -126,-436 -171,-424 L -134,-221 -89,-221 -73,-317 C -56,-332 -29,-340 9,-340 99,-340 194,-250 294,-70 L 339,12 156,870 44,895 52,940 Z"/>
+   <glyph unicode="x" horiz-adv-x="927" d="M 142,84 C 142,65 156,52 184,45 L 176,0 -9,0 C -20,9 -25,23 -25,43 -25,62 -14,85 7,112 28,139 63,176 112,221 L 385,475 213,870 106,895 114,940 362,940 507,582 631,700 C 674,741 704,773 721,796 738,819 747,839 747,856 747,863 744,869 738,874 732,879 715,886 688,895 L 696,940 873,940 C 887,929 894,915 894,897 894,858 848,794 756,707 L 542,506 734,66 850,45 842,0 586,0 419,400 248,236 C 211,201 185,172 168,149 151,126 142,104 142,84 Z"/>
    <glyph unicode="u" horiz-adv-x="875" d="M 268,193 C 268,163 276,139 292,120 308,101 333,92 368,92 418,92 472,113 530,155 588,196 636,247 673,308 L 784,940 950,940 797,70 915,45 907,0 629,0 656,193 C 601,122 543,68 483,31 423,-6 364,-24 305,-24 238,-24 187,-6 153,31 119,67 102,119 102,187 102,197 104,215 108,241 111,266 147,476 215,871 L 104,895 112,940 393,940 291,359 C 276,275 268,220 268,193 Z"/>
    <glyph unicode="t" horiz-adv-x="531" d="M 264,174 C 264,144 272,122 287,107 302,92 321,84 344,84 393,84 443,94 496,114 L 517,67 C 435,9 352,-20 268,-20 215,-20 174,-4 144,28 113,60 98,105 98,162 98,181 100,204 104,231 107,257 144,465 213,856 L 90,856 98,901 231,940 368,1153 432,1153 395,940 610,940 594,856 379,856 282,307 C 270,246 264,201 264,174 Z"/>
    <glyph unicode="s" horiz-adv-x="742" d="M 692,276 C 692,175 660,101 596,53 532,4 435,-20 305,-20 213,-20 120,1 25,42 L 66,268 111,268 128,131 C 145,112 170,96 202,81 233,66 269,59 309,59 455,59 528,119 528,238 528,277 513,312 482,343 451,374 400,406 330,440 263,473 213,509 180,549 147,588 131,635 131,688 131,776 161,844 220,893 279,941 362,965 467,965 542,965 632,953 735,930 L 698,721 651,721 637,829 C 595,866 540,885 471,885 416,885 373,873 340,848 307,823 291,784 291,731 291,695 305,663 333,636 361,609 414,575 492,535 561,499 612,460 644,419 676,378 692,330 692,276 Z"/>
@@ -113,13 +117,20 @@
    <glyph unicode="c" horiz-adv-x="848" d="M 774,142 C 720,92 659,53 592,24 525,-5 461,-20 400,-20 293,-20 210,11 151,73 92,135 63,221 63,330 63,446 86,552 133,648 180,743 246,820 333,878 419,936 509,965 604,965 651,965 702,960 755,950 808,940 852,928 887,913 L 842,651 787,651 771,825 C 729,867 673,888 603,888 539,888 479,864 424,817 368,770 323,704 290,619 257,534 240,441 240,340 240,169 309,84 446,84 541,84 641,117 744,184 L 774,142 Z"/>
    <glyph unicode="b" horiz-adv-x="927" d="M 305,1352 L 172,1376 180,1421 480,1421 406,980 C 395,904 382,840 367,787 420,842 475,885 532,917 588,949 640,965 687,965 770,965 837,935 887,876 937,816 962,734 962,631 962,516 937,408 888,307 838,205 769,125 682,67 595,9 499,-20 396,-20 337,-20 280,-12 224,3 167,18 118,38 76,64 L 305,1352 Z M 248,107 C 287,75 340,59 409,59 477,59 540,84 598,135 655,185 701,253 734,338 767,423 783,512 783,605 783,680 768,738 737,779 706,820 664,840 612,840 573,840 530,827 485,801 439,775 395,742 354,701 L 248,107 Z"/>
    <glyph unicode="a" horiz-adv-x="901" d="M 789,70 L 902,45 894,0 609,0 638,156 C 525,38 422,-21 329,-21 248,-21 184,9 135,68 86,127 61,209 61,313 61,430 87,539 138,641 189,742 257,822 342,879 427,936 520,964 620,964 701,964 777,950 848,922 L 893,956 947,956 789,70 Z M 760,837 C 734,855 710,868 687,875 664,882 636,885 603,885 536,885 475,860 420,810 364,759 320,691 288,606 256,521 240,432 240,339 240,268 255,211 284,168 313,125 353,104 404,104 479,104 562,150 651,243 L 760,837 Z"/>
+   <glyph unicode="V" horiz-adv-x="1350" d="M 1448,1341 L 1438,1288 1307,1262 580,-31 529,-31 234,1262 107,1288 117,1341 610,1341 600,1288 431,1262 649,283 1186,1262 1034,1288 1045,1341 1448,1341 Z"/>
+   <glyph unicode="R" horiz-adv-x="1244" d="M 444,588 L 354,80 533,53 523,0 -11,0 -1,53 161,80 370,1262 202,1288 212,1341 744,1341 C 890,1341 1001,1313 1078,1258 1155,1203 1193,1122 1193,1016 1193,805 1076,672 843,616 L 1070,80 1217,53 1207,0 899,0 653,588 444,588 Z M 616,678 C 737,678 831,707 897,765 962,822 995,904 995,1010 995,1171 900,1251 709,1251 L 561,1251 460,678 616,678 Z"/>
+   <glyph unicode="M" horiz-adv-x="1826" d="M 721,0 L 686,0 455,1153 266,80 442,53 432,0 -24,0 -14,53 161,80 370,1262 202,1288 212,1341 594,1341 800,318 1398,1341 1800,1341 1790,1288 1614,1262 1405,80 1573,53 1563,0 1019,0 1029,53 1213,80 1402,1153 721,0 Z"/>
+   <glyph unicode="6" horiz-adv-x="954" d="M 477,-20 C 353,-20 256,21 187,103 118,185 83,299 83,446 83,612 110,765 165,905 219,1044 296,1154 395,1235 494,1316 603,1356 723,1356 814,1356 911,1338 1014,1303 L 973,1072 907,1072 896,1212 C 837,1252 777,1272 716,1272 612,1272 522,1222 447,1122 371,1022 317,883 285,706 336,736 390,760 447,777 504,794 556,803 604,803 713,803 797,776 858,722 918,668 948,594 948,499 948,398 929,308 892,230 855,151 800,90 729,46 658,2 574,-20 477,-20 Z M 260,411 C 260,299 279,212 316,151 353,90 408,59 479,59 569,59 639,97 688,174 737,251 762,356 762,489 762,562 746,616 714,653 681,689 631,707 562,707 485,707 390,686 276,645 265,569 260,491 260,411 Z"/>
+   <glyph unicode="5" horiz-adv-x="954" d="M 490,784 C 627,784 730,756 801,699 871,642 906,560 906,454 906,302 859,185 765,103 670,21 534,-20 356,-20 241,-20 133,-6 32,23 L 70,305 136,305 148,117 C 172,102 205,89 248,79 291,68 331,63 370,63 487,63 575,94 634,156 693,218 723,314 723,445 723,615 636,700 463,700 391,700 324,692 262,676 L 166,676 283,1341 963,1341 936,1188 346,1188 271,760 C 347,776 420,784 490,784 Z"/>
+   <glyph unicode="2" horiz-adv-x="980" d="M 821,0 L 1,0 27,147 239,302 C 386,405 498,494 576,569 654,643 712,721 750,803 787,884 806,972 806,1067 806,1138 787,1190 748,1223 709,1256 653,1272 578,1272 541,1272 503,1267 463,1257 422,1246 388,1234 361,1219 L 297,1055 231,1055 276,1313 C 403,1342 509,1356 593,1356 717,1356 812,1331 879,1280 946,1229 979,1158 979,1067 979,980 958,896 917,815 876,734 813,656 729,579 644,502 527,411 378,306 L 166,154 848,154 821,0 Z"/>
+   <glyph unicode="0" horiz-adv-x="953" d="M 419,-20 C 192,-20 79,120 79,399 79,556 103,715 151,878 199,1040 265,1161 349,1242 432,1322 533,1362 652,1362 883,1362 998,1225 998,951 998,800 974,641 926,474 877,307 811,183 728,102 644,21 541,-20 419,-20 Z M 823,992 C 823,1185 760,1282 634,1282 577,1282 527,1263 484,1224 441,1185 404,1127 373,1050 342,972 313,866 288,731 262,596 249,468 249,345 249,251 265,180 297,132 328,83 373,59 431,59 510,59 577,95 630,168 683,241 729,363 767,536 804,708 823,860 823,992 Z"/>
    <glyph unicode=")" horiz-adv-x="742" d="M -97,-436 L -82,-352 C 5,-306 79,-248 138,-178 197,-108 245,-27 284,64 323,155 358,283 390,446 422,609 438,745 438,854 438,970 420,1068 383,1147 346,1226 289,1289 214,1337 L 229,1421 C 370,1337 471,1244 530,1143 589,1042 619,918 619,772 619,661 604,537 574,400 543,263 500,144 445,43 390,-59 319,-148 234,-224 149,-299 38,-370 -97,-436 Z"/>
    <glyph unicode="(" horiz-adv-x="742" d="M 251,131 C 251,-95 326,-256 475,-352 L 460,-436 C 322,-355 223,-264 163,-161 102,-58 72,66 72,213 72,330 87,457 118,593 148,728 191,846 246,946 301,1046 370,1134 455,1209 540,1284 650,1354 787,1421 L 772,1337 C 683,1290 609,1232 549,1161 489,1090 439,1006 400,911 361,816 326,686 296,522 266,358 251,228 251,131 Z"/>
    <glyph unicode=" " horiz-adv-x="503"/>
   </font>
  </defs>
  <defs class="TextShapeIndex">
-  <g ooo:slide="id1" ooo:id-list="id3 id4 id5 id6 id7 id8 id9 id10 id11 id12 id13 id14 id15 id16 id17 id18 id19 id20 id21 id22 id23 id24 id25 id26 id27 id28 id29 id30 id31 id32 id33 id34 id35 id36 id37 id38 id39 id40 id41 id42 id43 id44 id45 id46 id47 id48 id49"/>
+  <g ooo:slide="id1" ooo:id-list="id3 id4 id5 id6 id7 id8 id9 id10 id11 id12 id13 id14 id15 id16 id17 id18 id19 id20 id21 id22 id23 id24 id25 id26 id27 id28 id29 id30 id31 id32 id33 id34 id35 id36 id37 id38 id39 id40 id41 id42 id43 id44 id45 id46 id47 id48 id49 id50"/>
  </defs>
  <defs class="EmbeddedBulletChars">
   <g id="bullet-char-template-57356" transform="scale(0.00048828125,-0.00048828125)">
@@ -192,7 +203,7 @@
         <rect class="BoundingBox" stroke="none" fill="none" x="1704" y="9750" width="5611" height="1213"/>
         <path fill="rgb(114,159,207)" stroke="none" d="M 4509,10935 L 1731,10935 1731,9777 7287,9777 7287,10935 4509,10935 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 4509,10935 L 1731,10935 1731,9777 7287,9777 7287,10935 4509,10935 Z"/>
-        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="2761" y="10527"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Convert to AST</tspan></tspan></tspan></text>
+        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="2244" y="10527"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Build compiler AST</tspan></tspan></tspan></text>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
@@ -307,18 +318,18 @@
       </g>
       <g class="com.sun.star.drawing.CustomShape">
        <g id="id22">
-        <rect class="BoundingBox" stroke="none" fill="none" x="13167" y="3306" width="5611" height="1213"/>
-        <path fill="rgb(129,172,166)" stroke="none" d="M 15972,4491 L 13194,4491 13194,3333 18750,3333 18750,4491 15972,4491 Z"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 15972,4491 L 13194,4491 13194,3333 18750,3333 18750,4491 15972,4491 Z"/>
-        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="14169" y="3793"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Select CodeGen</tspan></tspan><tspan class="TextPosition" x="14861" y="4373"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">for target</tspan></tspan></tspan></text>
+        <rect class="BoundingBox" stroke="none" fill="none" x="13411" y="3125" width="5611" height="1555"/>
+        <path fill="rgb(129,172,166)" stroke="none" d="M 16216,4652 L 13438,4652 13438,3152 18994,3152 18994,4652 16216,4652 Z"/>
+        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 16216,4652 L 13438,4652 13438,3152 18994,3152 18994,4652 16216,4652 Z"/>
+        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="14106" y="3783"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Build simpler AST </tspan></tspan><tspan class="TextPosition" x="14823" y="4363"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">for codegen</tspan></tspan></tspan></text>
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
        <g id="id23">
-        <rect class="BoundingBox" stroke="none" fill="none" x="7287" y="3772" width="5908" height="15290"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 7687,18921 L 10241,18921 10241,3912 12934,3912"/>
+        <rect class="BoundingBox" stroke="none" fill="none" x="7287" y="3762" width="6152" height="15300"/>
+        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 7687,18921 L 10363,18921 10363,3902 13178,3902"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 7706,18921 L 7287,19061 7287,18782 7706,18921 Z"/>
-        <path fill="rgb(52,101,164)" stroke="none" d="M 12915,3773 L 13194,3912 12915,4052 12915,3773 Z"/>
+        <path fill="rgb(52,101,164)" stroke="none" d="M 13159,3763 L 13438,3902 13159,4042 13159,3763 Z"/>
        </g>
       </g>
       <g class="TextShape">
@@ -329,21 +340,6 @@
       </g>
       <g class="com.sun.star.drawing.CustomShape">
        <g id="id25">
-        <rect class="BoundingBox" stroke="none" fill="none" x="14723" y="5621" width="4305" height="1907"/>
-        <path fill="rgb(129,172,166)" stroke="none" d="M 16875,7500 L 14750,7500 14750,5648 19000,5648 19000,7500 16875,7500 Z"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 16875,7500 L 14750,7500 14750,5648 19000,5648 19000,7500 16875,7500 Z"/>
-        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="16230" y="6165"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Make </tspan></tspan><tspan class="TextPosition" x="15330" y="6745"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Intermediate </tspan></tspan><tspan class="TextPosition" x="16420" y="7325"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">AST</tspan></tspan></tspan></text>
-       </g>
-      </g>
-      <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id26">
-        <rect class="BoundingBox" stroke="none" fill="none" x="15945" y="4464" width="1071" height="1185"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 15972,4491 L 15972,5070 16875,5070 16875,5388"/>
-        <path fill="rgb(52,101,164)" stroke="none" d="M 17015,5369 L 16875,5648 16736,5369 17015,5369 Z"/>
-       </g>
-      </g>
-      <g class="com.sun.star.drawing.CustomShape">
-       <g id="id27">
         <rect class="BoundingBox" stroke="none" fill="none" x="14723" y="8472" width="4305" height="1444"/>
         <path fill="rgb(129,172,166)" stroke="none" d="M 16875,9888 L 14750,9888 14750,8499 19000,8499 19000,9888 16875,9888 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 16875,9888 L 14750,9888 14750,8499 19000,8499 19000,9888 16875,9888 Z"/>
@@ -351,14 +347,14 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id28">
-        <rect class="BoundingBox" stroke="none" fill="none" x="16735" y="7473" width="281" height="1028"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16875,7500 L 16875,8240"/>
+       <g id="id26">
+        <rect class="BoundingBox" stroke="none" fill="none" x="16735" y="7625" width="281" height="876"/>
+        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16869,7652 L 16869,8063 16875,8063 16875,8240"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 17015,8221 L 16875,8500 16736,8221 17015,8221 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id29">
+       <g id="id27">
         <rect class="BoundingBox" stroke="none" fill="none" x="14723" y="10972" width="4305" height="1444"/>
         <path fill="rgb(129,172,166)" stroke="none" d="M 16875,12388 L 14750,12388 14750,10999 19000,10999 19000,12388 16875,12388 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 16875,12388 L 14750,12388 14750,10999 19000,10999 19000,12388 16875,12388 Z"/>
@@ -366,35 +362,22 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id30">
+       <g id="id28">
         <rect class="BoundingBox" stroke="none" fill="none" x="16735" y="9862" width="281" height="1139"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16875,9889 L 16875,10740"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 17015,10721 L 16875,11000 16736,10721 17015,10721 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id31">
+       <g id="id29">
         <rect class="BoundingBox" stroke="none" fill="none" x="13157" y="14223" width="3620" height="1457"/>
         <path fill="rgb(255,166,166)" stroke="none" d="M 14967,15652 L 13184,15652 13184,14250 16749,14250 16749,15652 14967,15652 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 14967,15652 L 13184,15652 13184,14250 16749,14250 16749,15652 14967,15652 Z"/>
         <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="13891" y="14832"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Generate </tspan></tspan><tspan class="TextPosition" x="13832" y="15412"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">6502 Asm</tspan></tspan></tspan></text>
        </g>
       </g>
-      <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id32">
-        <rect class="BoundingBox" stroke="none" fill="none" x="12223" y="4464" width="3777" height="10628"/>
-        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 15972,4491 L 15972,5019 12250,5019 12250,14951 12925,14951"/>
-        <path fill="rgb(52,101,164)" stroke="none" d="M 12906,14812 L 13185,14951 12906,15091 12906,14812 Z"/>
-       </g>
-      </g>
-      <g class="TextShape">
-       <g id="id33">
-        <rect class="BoundingBox" stroke="none" fill="none" x="12223" y="5084" width="2778" height="1167"/>
-        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Liberation Serif, serif" font-size="388px" font-style="italic" font-weight="400"><tspan class="TextPosition" x="12473" y="5556"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">(depends </tspan></tspan><tspan class="TextPosition" x="12473" y="5988"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">on codegen)</tspan></tspan></tspan></text>
-       </g>
-      </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id34">
+       <g id="id30">
         <rect class="BoundingBox" stroke="none" fill="none" x="13167" y="16269" width="3611" height="1509"/>
         <path fill="rgb(255,166,166)" stroke="none" d="M 14972,17750 L 13194,17750 13194,16296 16750,16296 16750,17750 14972,17750 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 14972,17750 L 13194,17750 13194,16296 16750,16296 16750,17750 14972,17750 Z"/>
@@ -402,14 +385,14 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id35">
+       <g id="id31">
         <rect class="BoundingBox" stroke="none" fill="none" x="14832" y="15625" width="281" height="672"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 14967,15652 L 14967,15974 14972,15974 14972,16036"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 15112,16017 L 14972,16296 14833,16017 15112,16017 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id36">
+       <g id="id32">
         <rect class="BoundingBox" stroke="none" fill="none" x="3025" y="998" width="2977" height="1393"/>
         <path fill="rgb(221,232,203)" stroke="none" d="M 3026,999 L 6000,999 6000,2116 C 4822,2107 4862,2335 3799,2389 3419,2356 3280,2331 3026,2293 L 3026,999 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" d="M 3026,999 L 6000,999 6000,2116 C 4822,2107 4862,2335 3799,2389 3419,2356 3280,2331 3026,2293 L 3026,999 Z"/>
@@ -417,14 +400,14 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id37">
+       <g id="id33">
         <rect class="BoundingBox" stroke="none" fill="none" x="4369" y="2280" width="281" height="1248"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 4514,2307 L 4514,2945 4509,2945 4509,3267"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 4649,3248 L 4509,3527 4370,3248 4649,3248 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id38">
+       <g id="id34">
         <rect class="BoundingBox" stroke="none" fill="none" x="13498" y="18609" width="2939" height="1393"/>
         <path fill="rgb(255,245,206)" stroke="none" d="M 13499,18610 L 16435,18610 16435,19727 C 15272,19718 15312,19946 14262,20000 13887,19967 13750,19942 13499,19904 L 13499,18610 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" d="M 13499,18610 L 16435,18610 16435,19727 C 15272,19718 15312,19946 14262,20000 13887,19967 13750,19942 13499,19904 L 13499,18610 Z"/>
@@ -432,41 +415,41 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id39">
+       <g id="id35">
         <rect class="BoundingBox" stroke="none" fill="none" x="14828" y="17723" width="281" height="889"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 14972,17750 L 14972,18193 14968,18193 14968,18351"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 15108,18332 L 14968,18611 14829,18332 15108,18332 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id40">
+       <g id="id36">
         <rect class="BoundingBox" stroke="none" fill="none" x="18809" y="17375" width="281" height="1028"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 18869,17402 L 18869,17902 18949,17902 18949,18142"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 19089,18123 L 18949,18402 18810,18123 19089,18123 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id41">
+       <g id="id37">
         <rect class="BoundingBox" stroke="none" fill="none" x="14827" y="12362" width="2076" height="1889"/>
         <path fill="none" stroke="rgb(183,179,202)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16875,12389 L 16875,13319 14967,13319 14967,13990"/>
         <path fill="rgb(183,179,202)" stroke="none" d="M 15107,13971 L 14967,14250 14828,13971 15107,13971 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id42">
+       <g id="id38">
         <rect class="BoundingBox" stroke="none" fill="none" x="16848" y="12362" width="2195" height="1652"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16875,12389 L 16875,13213 18902,13213 18902,13753"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 19042,13734 L 18902,14013 18763,13734 19042,13734 Z"/>
        </g>
       </g>
       <g class="TextShape">
-       <g id="id43">
+       <g id="id39">
         <rect class="BoundingBox" stroke="none" fill="none" x="13473" y="13084" width="2778" height="1167"/>
         <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Liberation Serif, serif" font-size="388px" font-style="italic" font-weight="400"><tspan class="TextPosition" x="13723" y="13556"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">(future)</tspan></tspan></tspan></text>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id44">
+       <g id="id40">
         <rect class="BoundingBox" stroke="none" fill="none" x="17125" y="18375" width="3647" height="1806"/>
         <path fill="rgb(255,166,166)" stroke="none" d="M 17729,20153 L 17729,20153 C 17628,20153 17528,20113 17441,20036 17353,19959 17280,19848 17229,19715 17179,19582 17152,19431 17152,19278 L 17152,19278 C 17152,19124 17179,18973 17229,18840 17280,18707 17353,18596 17441,18519 17528,18442 17628,18402 17729,18402 L 20166,18402 20167,18402 C 20268,18402 20368,18442 20455,18519 20543,18596 20616,18707 20667,18840 20717,18973 20744,19124 20744,19278 L 20744,19278 20744,19278 C 20744,19431 20717,19582 20667,19715 20616,19848 20543,19959 20455,20036 20368,20113 20268,20153 20167,20153 L 17729,20153 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 17729,20153 L 17729,20153 C 17628,20153 17528,20113 17441,20036 17353,19959 17280,19848 17229,19715 17179,19582 17152,19431 17152,19278 L 17152,19278 C 17152,19124 17179,18973 17229,18840 17280,18707 17353,18596 17441,18519 17528,18442 17628,18402 17729,18402 L 20166,18402 20167,18402 C 20268,18402 20368,18442 20455,18519 20543,18596 20616,18707 20667,18840 20717,18973 20744,19124 20744,19278 L 20744,19278 20744,19278 C 20744,19431 20717,19582 20667,19715 20616,19848 20543,19959 20455,20036 20368,20113 20268,20153 20167,20153 L 17729,20153 Z"/>
@@ -474,7 +457,7 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id45">
+       <g id="id41">
         <rect class="BoundingBox" stroke="none" fill="none" x="17217" y="15973" width="3305" height="1457"/>
         <path fill="rgb(255,166,166)" stroke="none" d="M 18869,17402 L 17244,17402 17244,16000 20494,16000 20494,17402 18869,17402 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 18869,17402 L 17244,17402 17244,16000 20494,16000 20494,17402 18869,17402 Z"/>
@@ -482,7 +465,7 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id46">
+       <g id="id42">
         <rect class="BoundingBox" stroke="none" fill="none" x="17307" y="14011" width="3189" height="1393"/>
         <path fill="rgb(255,245,206)" stroke="none" d="M 17308,14012 L 20494,14012 20494,15129 C 19232,15120 19275,15348 18136,15402 17729,15369 17580,15344 17308,15306 L 17308,14012 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" d="M 17308,14012 L 20494,14012 20494,15129 C 19232,15120 19275,15348 18136,15402 17729,15369 17580,15344 17308,15306 L 17308,14012 Z"/>
@@ -490,14 +473,14 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id47">
+       <g id="id43">
         <rect class="BoundingBox" stroke="none" fill="none" x="18729" y="15293" width="281" height="708"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 18902,15320 L 18902,15688 18869,15688 18869,15740"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 19009,15721 L 18869,16000 18730,15721 19009,15721 Z"/>
        </g>
       </g>
       <g class="com.sun.star.drawing.CustomShape">
-       <g id="id48">
+       <g id="id44">
         <rect class="BoundingBox" stroke="none" fill="none" x="13125" y="20625" width="3647" height="1806"/>
         <path fill="rgb(255,166,166)" stroke="none" d="M 13729,22403 L 13729,22403 C 13628,22403 13528,22363 13441,22286 13353,22209 13280,22098 13229,21965 13179,21832 13152,21681 13152,21528 L 13152,21528 C 13152,21374 13179,21223 13229,21090 13280,20957 13353,20846 13441,20769 13528,20692 13628,20652 13729,20652 L 16166,20652 16167,20652 C 16268,20652 16368,20692 16455,20769 16543,20846 16616,20957 16667,21090 16717,21223 16744,21374 16744,21528 L 16744,21528 16744,21528 C 16744,21681 16717,21832 16667,21965 16616,22098 16543,22209 16455,22286 16368,22363 16268,22403 16167,22403 L 13729,22403 Z"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="round" d="M 13729,22403 L 13729,22403 C 13628,22403 13528,22363 13441,22286 13353,22209 13280,22098 13229,21965 13179,21832 13152,21681 13152,21528 L 13152,21528 C 13152,21374 13179,21223 13229,21090 13280,20957 13353,20846 13441,20769 13528,20692 13628,20652 13729,20652 L 16166,20652 16167,20652 C 16268,20652 16368,20692 16455,20769 16543,20846 16616,20957 16667,21090 16717,21223 16744,21374 16744,21528 L 16744,21528 16744,21528 C 16744,21681 16717,21832 16667,21965 16616,22098 16543,22209 16455,22286 16368,22363 16268,22403 16167,22403 L 13729,22403 Z"/>
@@ -505,12 +488,46 @@
        </g>
       </g>
       <g class="com.sun.star.drawing.ConnectorShape">
-       <g id="id49">
+       <g id="id45">
         <rect class="BoundingBox" stroke="none" fill="none" x="14809" y="19891" width="281" height="762"/>
         <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 14968,19918 L 14968,20313 14949,20313 14949,20392"/>
         <path fill="rgb(52,101,164)" stroke="none" d="M 15089,20373 L 14949,20652 14810,20373 15089,20373 Z"/>
        </g>
       </g>
+      <g class="com.sun.star.drawing.CustomShape">
+       <g id="id46">
+        <rect class="BoundingBox" stroke="none" fill="none" x="14243" y="5401" width="5254" height="2254"/>
+        <path fill="rgb(129,172,166)" stroke="none" d="M 16869,5402 L 19495,6527 16869,7653 14244,6527 16869,5402 16869,5402 Z"/>
+        <path fill="none" stroke="rgb(52,101,164)" d="M 16869,5402 L 19495,6527 16869,7653 14244,6527 16869,5402 16869,5402 Z"/>
+        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Droid Serif, serif" font-size="494px" font-weight="400"><tspan class="TextPosition" x="15862" y="6408"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Codegen </tspan></tspan><tspan class="TextPosition" x="16111" y="6988"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">choice</tspan></tspan></tspan></text>
+       </g>
+      </g>
+      <g class="com.sun.star.drawing.ConnectorShape">
+       <g id="id47">
+        <rect class="BoundingBox" stroke="none" fill="none" x="16189" y="4625" width="821" height="778"/>
+        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 16216,4652 L 16216,5040 16869,5040 16869,5142"/>
+        <path fill="rgb(52,101,164)" stroke="none" d="M 17009,5123 L 16869,5402 16730,5123 17009,5123 Z"/>
+       </g>
+      </g>
+      <g class="TextShape">
+       <g id="id48">
+        <rect class="BoundingBox" stroke="none" fill="none" x="16994" y="7486" width="2778" height="1167"/>
+        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Liberation Serif, serif" font-size="388px" font-style="italic" font-weight="400"><tspan class="TextPosition" x="17244" y="7958"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">VM or experi</tspan></tspan></tspan></text>
+       </g>
+      </g>
+      <g class="com.sun.star.drawing.ConnectorShape">
+       <g id="id49">
+        <rect class="BoundingBox" stroke="none" fill="none" x="12630" y="6500" width="1642" height="8592"/>
+        <path fill="none" stroke="rgb(52,101,164)" stroke-width="53" stroke-linejoin="miter" stroke-linecap="round" d="M 14244,6527 L 12657,6527 12657,14951 12925,14951"/>
+        <path fill="rgb(52,101,164)" stroke="none" d="M 12906,14812 L 13185,14951 12906,15091 12906,14812 Z"/>
+       </g>
+      </g>
+      <g class="TextShape">
+       <g id="id50">
+        <rect class="BoundingBox" stroke="none" fill="none" x="11244" y="7152" width="2778" height="1167"/>
+        <text class="SVGTextShape"><tspan class="TextParagraph" font-family="Liberation Serif, serif" font-size="388px" font-style="italic" font-weight="400"><tspan class="TextPosition" x="11494" y="7624"><tspan fill="rgb(0,0,0)" stroke="none" style="white-space: pre">Regular 6502</tspan></tspan></tspan></text>
+       </g>
+      </g>
      </g>
     </g>
    </g>

docs/source/todo.rst

@@ -17,7 +17,7 @@ For 9.0 major changes
     - OR.... make all this more generic and use some %segment option to create real segments for 64tass?
     - (need separate step in codegen and IR to write the "golden" variables)
 
-- rewrite 6502 codegen on Pt* ast and symboltable, instead of CompilerAst nodes. (work in codegen-on-new-ast branch)
+- rewrite 6502 codegen on Pt* ast and symboltable, instead of CompilerAst nodes.
     - optimize "dotted string" comments again.
 
 
@@ -42,7 +42,7 @@ Compiler:
 - ir: peephole opt: reuse registers in chunks (but keep result registers in mind that pass values out! and don't renumber registers above SyscallRegisterBase!)
 - ir: add more optimizations in IRPeepholeOptimizer
 - ir: for expressions with array indexes that occur multiple times, can we avoid loading them into new virtualregs everytime and just reuse a single virtualreg as indexer?
-- vm: somehow be able to load a label address as value? (VmProgramLoader)
+- vm: somehow be able to load a label address as value? (VmProgramLoader) this may require storing the program in actual memory bytes though...
 - 6502 codegen: see if we can let for loops skip the loop if startvar>endvar, without adding a lot of code size/duplicating the loop condition.
   It is documented behavior to now loop 'around' $00 but it's too easy to forget about!
   Lot of work because of so many special cases in ForLoopsAsmgen.....  (vm codegen already behaves like this)
@@ -56,14 +56,7 @@ Compiler:
   Once new codegen is written that is based on the IR, this point is moot anyway as that will have its own dead code removal.
 - Zig-like try-based error handling where the V flag could indicate error condition? and/or BRK to jump into monitor on failure? (has to set BRK vector for that)
 - add special (u)word array type (or modifier?) that puts the array into memory as 2 separate byte-arrays 1 for LSB 1 for MSB -> allows for word arrays of length 256 and faster indexing
-- Add a mechanism to allocate variables into golden ram (or segments really) (see GoldenRam class)
-    - block "golden" treated specially: every var in here will be allocated in the Golden ram area
-    - that block can only contain variables.
-    - the variables can NOT have initialization values, they will all be set to zero on startup (simple memset)
-    - just initialize them yourself in start() if you need a non-zero value
-    - OR.... do all this automatically if 'golden' is enabled as a compiler option? So compiler allocates in ZP first, then Golden Ram, then regular ram
-    - OR.... make all this more generic and use some %segment option to create real segments for 64tass?
-    - (need separate step in codegen and IR to write the "golden" variables)
+
 
 Libraries:
 
@@ -94,6 +87,7 @@ Optimizations:
 - when a loopvariable of a forloop isn't referenced in the body, and the iterations are known, replace the loop by a repeatloop
   but we have no efficient way right now to see if the body references a variable.
 - optimize function argument expressions better (use temporary variables to replace non-simple expressions?)
+- 6502 codegen optimize array1[index] += / -= array2[index]  to not use slow stackeval (attemptAssignOptimizedBinexpr)
 
 
 STRUCTS again?

examples/test.p8

@@ -1,52 +1,13 @@
-%import textio
 %zeropage basicsafe
-%option no_sysinit
 
 main {
-    ubyte @requirezp zpvar = 10
-    ubyte @zp zpvar2 = 20
-    uword empty
-    ubyte[10] bssarray
-    uword[10] bsswordarray
-    ubyte[10] nonbssarray = 99
-    str name="irmen"
+
+    &ubyte[40] topline = $0400
 
     sub start() {
-        txt.print("= 10 ")
-        txt.print_ub(zpvar)
-        txt.nl()
-        zpvar++
-
-        txt.print("= 20 ")
-        txt.print_ub(zpvar2)
-        txt.nl()
-        zpvar2++
-
-        txt.print("= 0 ")
-        txt.print_uw(empty)
-        txt.nl()
-        empty++
-
-        txt.print("+ 0 ")
-        txt.print_ub(bssarray[1])
-        txt.nl()
-        bssarray[1]++
-
-        txt.print("+ 0 ")
-        txt.print_uw(bsswordarray[1])
-        txt.nl()
-        bsswordarray[1]++
-
-        txt.print("+ 99 ")
-        txt.print_ub(nonbssarray[1])
-        txt.nl()
-        nonbssarray[1]++
-
-        txt.print("+ r ")
-        txt.chrout(name[1])
-        txt.nl()
-        name[1] = (name[1] as ubyte +1)
-
-        txt.print("try running again.\n")
+        topline[0] = 'a'
+        topline[1] = 'b'
+        topline[2] = 'd'
+        topline[39] = '@'
     }
 }

intermediate/src/prog8/intermediate/IRFileReader.kt

@@ -1,6 +1,7 @@
 package prog8.intermediate
 
 import prog8.code.*
+import prog8.code.ast.PtVariable
 import prog8.code.core.*
 import prog8.code.target.*
 import java.io.StringReader
@@ -170,7 +171,9 @@ class IRFileReader {
                 val arraysize = if(arrayspec.isNotBlank()) arrayspec.substring(1, arrayspec.length-1).toInt() else null
                 val dt: DataType = parseDatatype(type, arraysize!=null)
                 val zp = if(zpwish.isBlank()) ZeropageWish.DONTCARE else ZeropageWish.valueOf(zpwish)
-                bssVariables.add(StStaticVariable(name, dt, true, null, null, null, arraysize, zp, Position.DUMMY))
+                val dummyNode = PtVariable(name, dt, zp, null, null, Position.DUMMY)
+                val newVar = StStaticVariable(name, dt, true, null, null, null, arraysize, zp, dummyNode)
+                bssVariables.add(newVar)
             }
             return bssVariables
         }
@@ -231,7 +234,8 @@ class IRFileReader {
                     else -> throw IRParseException("weird dt")
                 }
                 require(!bss) { "bss var should be in BSS section" }
-                variables.add(StStaticVariable(name, dt, bss, initNumeric, null, initArray, arraysize, zp, Position.DUMMY))
+                val dummyNode = PtVariable(name, dt, zp, null, null, Position.DUMMY)
+                variables.add(StStaticVariable(name, dt, bss, initNumeric, null, initArray, arraysize, zp, dummyNode))
             }
             return variables
         }
@@ -257,7 +261,8 @@ class IRFileReader {
                 val (type, arrayspec, name, address) = match.destructured
                 val arraysize = if(arrayspec.isNotBlank()) arrayspec.substring(1, arrayspec.length-1).toInt() else null
                 val dt: DataType = parseDatatype(type, arraysize!=null)
-                memvars.add(StMemVar(name, dt, parseIRValue(address).toUInt(), arraysize, Position.DUMMY))
+                val dummyNode = PtVariable(name, dt, ZeropageWish.NOT_IN_ZEROPAGE, null, null, Position.DUMMY)
+                memvars.add(StMemVar(name, dt, parseIRValue(address).toUInt(), arraysize, dummyNode))
             }
             memvars
         }
@@ -279,7 +284,8 @@ class IRFileReader {
                 // example: "SLAB slabname 4096 0"
                 val match = slabPattern.matchEntire(line) ?: throw IRParseException("invalid SLAB $line")
                 val (name, size, align) = match.destructured
-                slabs.add(StMemorySlab(name, size.toUInt(), align.toUInt(), Position.DUMMY))
+                val dummyNode = PtVariable(name, DataType.ARRAY_UB, ZeropageWish.NOT_IN_ZEROPAGE, null, null, Position.DUMMY)
+                slabs.add(StMemorySlab(name, size.toUInt(), align.toUInt(), dummyNode))
             }
             slabs
         }

intermediate/src/prog8/intermediate/IRSymbolTable.kt

@@ -1,6 +1,9 @@
 package prog8.intermediate
 
 import prog8.code.*
+import prog8.code.ast.PtVariable
+import prog8.code.core.DataType
+import prog8.code.core.ZeropageWish
 
 
 // In the Intermediate Representation, all nesting has been removed.
@@ -71,13 +74,14 @@ class IRSymbolTable(sourceSt: SymbolTable?) {
                 return newArray
             }
             scopedName = variable.scopedName
+            val dummyNode = PtVariable(scopedName, variable.dt, variable.zpwish, null, null, variable.astNode.position)
             varToadd = StStaticVariable(scopedName, variable.dt, variable.bss,
                 variable.onetimeInitializationNumericValue,
                 variable.onetimeInitializationStringValue,
                 fixupAddressOfInArray(variable.onetimeInitializationArrayValue),
                 variable.length,
                 variable.zpwish,
-                variable.position
+                dummyNode
             )
         }
         table[scopedName] = varToadd
@@ -92,7 +96,8 @@ class IRSymbolTable(sourceSt: SymbolTable?) {
             varToadd = variable
         } else {
             scopedName = variable.scopedName
-            varToadd = StMemVar(scopedName, variable.dt, variable.address, variable.length, variable.position)
+            val dummyNode = PtVariable(scopedName, variable.dt, ZeropageWish.NOT_IN_ZEROPAGE, null, null, variable.astNode.position)
+            varToadd = StMemVar(scopedName, variable.dt, variable.address, variable.length, dummyNode)
         }
         table[scopedName] = varToadd
     }
@@ -100,8 +105,10 @@ class IRSymbolTable(sourceSt: SymbolTable?) {
     fun add(variable: StMemorySlab) {
         val varToadd = if('.' in variable.name)
             variable
-        else
-            StMemorySlab("prog8_slabs.${variable.name}", variable.size, variable.align, variable.position)
+        else {
+            val dummyNode = PtVariable(variable.name, DataType.ARRAY_UB, ZeropageWish.NOT_IN_ZEROPAGE, null, null, variable.astNode.position)
+            StMemorySlab("prog8_slabs.${variable.name}", variable.size, variable.align, dummyNode)
+        }
         table[varToadd.name] = varToadd
     }