examples

improved cli parser by using kotlinx.cli

.idea/libraries/kotlinx_cli_jvm_0_1_0_dev_5.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="kotlinx-cli-jvm-0.1.0-dev-5">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/compiler/lib/kotlinx-cli-jvm-0.1.0-dev-5.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

compiler/build.gradle

@@ -20,6 +20,7 @@ repositories {
     mavenLocal()
     mavenCentral()
     jcenter()
+    maven { url "https://dl.bintray.com/orangy/maven/" }
 }
 
 def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
@@ -35,14 +36,14 @@ dependencies {
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVersion"
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.2'
     testImplementation 'org.hamcrest:hamcrest-junit:2.0.0.0'
-
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.3.2'
+    compile 'org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-5'
 }
 
 compileKotlin {
     kotlinOptions {
         jvmTarget = "1.8"
-        verbose = true
+        // verbose = true
         // freeCompilerArgs += "-XXLanguage:+NewInference"
     }
 }

compiler/compiler.iml

@@ -14,5 +14,6 @@
     <orderEntry type="library" name="antlr-runtime-4.7.2" level="project" />
     <orderEntry type="module" module-name="parser" />
     <orderEntry type="library" name="unittest-libs" level="project" />
+    <orderEntry type="library" name="kotlinx-cli-jvm-0.1.0-dev-5" level="project" />
   </component>
 </module>

compiler/res/prog8lib/prog8lib.asm

@@ -1671,3 +1671,91 @@ _loop_hi	sty  c64.SCRATCH_ZPREG
 
 		rts	
 		.pend
+
+ror2_mem_ub	.proc
+		; -- in-place 8-bit ror of byte at memory location on stack
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		ldy  #0
+		lda  (c64.SCRATCH_ZPWORD1),y
+		lsr  a
+		bcc  +
+		ora  #$80
++		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+		
+rol2_mem_ub	.proc
+		; -- in-place 8-bit rol of byte at memory location on stack
+		;"  lda  ${number.toHex()} |  cmp  #\$80 |  rol  a |  sta  ${number.toHex()}"
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  c64.SCRATCH_ZPWORD1
+		lda  c64.ESTACK_HI,x
+		sta  c64.SCRATCH_ZPWORD1+1
+		ldy  #0
+		lda  (c64.SCRATCH_ZPWORD1),y
+		cmp  #$80
+		rol  a
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+		
+lsl_array_b	.proc
+		.warn "lsl_array_b"		; TODO
+		.pend
+		
+lsl_array_w	.proc
+		.warn "lsl_array_w"		; TODO
+		.pend
+		
+lsr_array_ub	.proc
+		.warn "lsr_array_ub"		; TODO
+		.pend
+		
+lsr_array_b	.proc
+		.warn "lsr_array_b"		; TODO
+		.pend
+		
+lsr_array_uw	.proc
+		.warn "lsl_array_uw"		; TODO
+		.pend
+		
+lsr_array_w	.proc
+		.warn "lsr_array_w"		; TODO
+		.pend
+		
+rol_array_ub	.proc
+		.warn "rol_array_ub"		; TODO
+		.pend
+		
+rol_array_uw	.proc
+		.warn "rol_array_uw"		; TODO
+		.pend
+		
+rol2_array_ub	.proc
+		.warn "rol2_array_ub"		; TODO
+		.pend
+		
+rol2_array_uw	.proc
+		.warn "rol2_array_uw"		; TODO
+		.pend
+		
+ror_array_ub	.proc
+		.warn "ror_array_ub"		; TODO
+		.pend
+		
+ror_array_uw	.proc
+		.warn "ror_array_uw"		; TODO
+		.pend
+		
+ror2_array_ub	.proc
+		.warn "ror2_array_ub"		; TODO
+		.pend
+		
+ror2_array_uw	.proc
+		.warn "ror2_array_uw"		; TODO
+		.pend

compiler/res/version.txt

@@ -1,2 +1,2 @@
-1.60
+1.61
 

compiler/src/prog8/CompilerMain.kt

@@ -1,5 +1,6 @@
 package prog8
 
+import kotlinx.cli.*
 import prog8.ast.base.AstException
 import prog8.compiler.CompilationResult
 import prog8.compiler.compileProgram
@@ -14,11 +15,8 @@ import kotlin.system.exitProcess
 
 
 fun main(args: Array<String>) {
-
     printSoftwareHeader("compiler")
 
-    if (args.isEmpty())
-        usage()
     compileMain(args)
 }
 
@@ -30,43 +28,37 @@ internal fun printSoftwareHeader(what: String) {
 
 
 private fun compileMain(args: Array<String>) {
-    var emulatorToStart = ""
-    var moduleFile = ""
-    var writeAssembly = true
-    var optimize = true
-    var launchAstVm = false
-    var watchMode = false
-    for (arg in args) {
-        if(arg=="-emu")
-            emulatorToStart = "x64"
-        else if(arg=="-emu2")
-            emulatorToStart = "x64sc"
-        else if(arg=="-noasm")
-            writeAssembly = false
-        else if(arg=="-noopt")
-            optimize = false
-        else if(arg=="-avm")
-            launchAstVm = true
-        else if(arg=="-watch")
-            watchMode = true
-        else if(!arg.startsWith("-"))
-            moduleFile = arg
-        else
-            usage()
+    val cli = CommandLineInterface("prog8compiler")
+    val startEmulator1 by cli.flagArgument("-emu", "auto-start the 'x64' C-64 emulator after successful compilation")
+    val startEmulator2 by cli.flagArgument("-emu2", "auto-start the 'x64sc' C-64 emulator after successful compilation")
+    val outputDir by cli.flagValueArgument("-out", "directory", "directory for output files instead of current directory", ".")
+    val dontWriteAssembly by cli.flagArgument("-noasm", "don't create assembly code")
+    val dontOptimize by cli.flagArgument("-noopt", "don't perform any optimizations")
+    val launchSimulator by cli.flagArgument("-sim", "launch the prog8 virtual machine/simulator after compilation")
+    val watchMode by cli.flagArgument("-watch", "continuous compilation mode (watches for file changes)")
+    val moduleFiles by cli.positionalArgumentsList("modules", "main module file(s) to compile", minArgs = 1)
+
+    try {
+        cli.parse(args)
+    } catch (e: Exception) {
+        exitProcess(1)
     }
 
-    if(watchMode) {
-        if(moduleFile.isBlank())
-            usage()
+    val outputPath = Paths.get(outputDir)
+    if(!outputPath.toFile().isDirectory) {
+        System.err.println("Output path doesn't exist")
+        exitProcess(1)
+    }
 
+    if(watchMode && moduleFiles.size<=1) {
         val watchservice = FileSystems.getDefault().newWatchService()
 
         while(true) {
-            val filepath = Paths.get(moduleFile).normalize()
+            val filepath = Paths.get(moduleFiles.single()).normalize()
             println("Continuous watch mode active. Main module: $filepath")
 
             try {
-                val compilationResult = compileProgram(filepath, optimize, writeAssembly)
+                val compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, outputDir=outputPath)
                 println("Imported files (now watching:)")
                 for (importedFile in compilationResult.importedFiles) {
                     print("  ")
@@ -87,51 +79,37 @@ private fun compileMain(args: Array<String>) {
         }
 
     } else {
-        if(moduleFile.isBlank())
-            usage()
-
-        val filepath = Paths.get(moduleFile).normalize()
-        val compilationResult: CompilationResult
-
-        try {
-            compilationResult = compileProgram(filepath, optimize, writeAssembly)
-            if(!compilationResult.success)
+        for(filepathRaw in moduleFiles) {
+            val filepath = Paths.get(filepathRaw).normalize()
+            val compilationResult: CompilationResult
+            try {
+                compilationResult = compileProgram(filepath, !dontOptimize, !dontWriteAssembly, outputDir=outputPath)
+                if(!compilationResult.success)
+                    exitProcess(1)
+            } catch (x: ParsingFailedError) {
                 exitProcess(1)
-        } catch (x: ParsingFailedError) {
-            exitProcess(1)
-        } catch (x: AstException) {
-            exitProcess(1)
-        }
+            } catch (x: AstException) {
+                exitProcess(1)
+            }
 
-        if (launchAstVm) {
-            println("\nLaunching AST-based vm...")
-            val vm = AstVm(compilationResult.programAst)
-            vm.run()
-        }
+            if (launchSimulator) {
+                println("\nLaunching AST-based simulator...")
+                val vm = AstVm(compilationResult.programAst)
+                vm.run()
+            }
 
-        if (emulatorToStart.isNotEmpty()) {
-            if (compilationResult.programName.isEmpty())
-                println("\nCan't start emulator because no program was assembled.")
-            else {
-                println("\nStarting C-64 emulator $emulatorToStart...")
-                val cmdline = listOf(emulatorToStart, "-silent", "-moncommands", "${compilationResult.programName}.vice-mon-list",
-                        "-autostartprgmode", "1", "-autostart-warp", "-autostart", compilationResult.programName + ".prg")
-                val process = ProcessBuilder(cmdline).inheritIO().start()
-                process.waitFor()
+            if (startEmulator1 || startEmulator2) {
+                if (compilationResult.programName.isEmpty())
+                    println("\nCan't start emulator because no program was assembled.")
+                else {
+                    val emulator = if(startEmulator1) "x64" else "x64sc"
+                    println("\nStarting C-64 emulator $emulator...")
+                    val cmdline = listOf(emulator, "-silent", "-moncommands", "${compilationResult.programName}.vice-mon-list",
+                            "-autostartprgmode", "1", "-autostart-warp", "-autostart", compilationResult.programName + ".prg")
+                    val process = ProcessBuilder(cmdline).inheritIO().start()
+                    process.waitFor()
+                }
             }
         }
     }
 }
-
-
-private fun usage() {
-    System.err.println("Missing argument(s):")
-    System.err.println("    [-noasm]        don't create assembly code")
-    System.err.println("    [-noopt]        don't perform any optimizations")
-    System.err.println("    [-emu]          auto-start the 'x64' C-64 emulator after successful compilation")
-    System.err.println("    [-emu2]         auto-start the 'x64sc' C-64 emulator after successful compilation")
-    System.err.println("    [-avm]          launch the prog8 ast-based virtual machine after compilation")
-    System.err.println("    [-watch]        continuous compilation mode (watches for file changes)")
-    System.err.println("    modulefile      main module file to compile")
-    exitProcess(1)
-}

compiler/src/prog8/ast/AstToplevel.kt

@@ -4,7 +4,6 @@ import prog8.ast.base.*
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.statements.*
-import prog8.compiler.HeapValues
 import prog8.functions.BuiltinFunctions
 import java.nio.file.Path
 
@@ -161,12 +160,15 @@ interface INameScope {
     }
 }
 
+interface IAssignable {
+    // just a tag for now
+}
+
 
 /*********** Everything starts from here, the Program; zero or more modules *************/
 
 class Program(val name: String, val modules: MutableList<Module>) {
     val namespace = GlobalNamespace(modules)
-    val heap = HeapValues()
 
     val definedLoadAddress: Int
         get() = modules.first().loadAddress

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

@@ -429,7 +429,7 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     else -> throw FatalAstException("invalid datatype for numeric literal")
                 }
                 litval.floatliteral()!=null -> NumericLiteralValue(DataType.FLOAT, litval.floatliteral().toAst(), litval.toPosition())
-                litval.stringliteral()!=null -> StringLiteralValue(DataType.STR, unescape(litval.stringliteral().text, litval.toPosition()), position = litval.toPosition())
+                litval.stringliteral()!=null -> StringLiteralValue(DataType.STR, unescape(litval.stringliteral().text, litval.toPosition()), litval.toPosition())
                 litval.charliteral()!=null -> {
                     try {
                         NumericLiteralValue(DataType.UBYTE, Petscii.encodePetscii(unescape(litval.charliteral().text, litval.toPosition()), true)[0], litval.toPosition())

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

@@ -5,7 +5,7 @@ import prog8.parser.ParsingFailedError
 
 fun printErrors(errors: List<Any>, moduleName: String) {
     val reportedMessages = mutableSetOf<String>()
-    print("\u001b[91m")  // bright red
+    System.err.print("\u001b[91m")  // bright red
     errors.forEach {
         val msg = it.toString()
         if(msg !in reportedMessages) {
@@ -13,7 +13,7 @@ fun printErrors(errors: List<Any>, moduleName: String) {
             reportedMessages.add(msg)
         }
     }
-    print("\u001b[0m")  // reset color
+    System.err.print("\u001b[0m")  // reset color
     if(reportedMessages.isNotEmpty())
         throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
 }

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

@@ -1,9 +1,6 @@
 package prog8.ast.expressions
 
-import prog8.ast.IFunctionCall
-import prog8.ast.INameScope
-import prog8.ast.Node
-import prog8.ast.Program
+import prog8.ast.*
 import prog8.ast.antlr.escape
 import prog8.ast.base.*
 import prog8.ast.processing.IAstModifyingVisitor
@@ -12,8 +9,6 @@ import prog8.ast.statements.ArrayIndex
 import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.VarDecl
-import prog8.compiler.HeapValues
-import prog8.compiler.IntegerOrAddressOf
 import prog8.compiler.target.c64.Petscii
 import prog8.functions.BuiltinFunctions
 import prog8.functions.NotConstArgumentException
@@ -185,7 +180,7 @@ class BinaryExpression(var left: Expression, var operator: String, var right: Ex
 
 class ArrayIndexedExpression(var identifier: IdentifierReference,
                              val arrayspec: ArrayIndex,
-                             override val position: Position) : Expression() {
+                             override val position: Position) : Expression(), IAssignable {
     override lateinit var parent: Node
     override fun linkParents(parent: Node) {
         this.parent = parent
@@ -254,7 +249,7 @@ data class AddressOf(var identifier: IdentifierReference, override val position:
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
 }
 
-class DirectMemoryRead(var addressExpression: Expression, override val position: Position) : Expression() {
+class DirectMemoryRead(var addressExpression: Expression, override val position: Position) : Expression(), IAssignable {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
@@ -414,13 +409,9 @@ class StructLiteralValue(var values: List<Expression>,
 
 class StringLiteralValue(val type: DataType,     // only string types
                          val value: String,
-                         initHeapId: Int? =null,
                          override val position: Position) : Expression() {
     override lateinit var parent: Node
 
-    var heapId = initHeapId
-        private set
-
     override fun linkParents(parent: Node) {
         this.parent = parent
     }
@@ -438,14 +429,18 @@ class StringLiteralValue(val type: DataType,     // only string types
         return value==other.value && type==other.type
     }
 
-    fun addToHeap(heap: HeapValues) {
-        if (heapId != null)
-            return
-        else
-            heapId = heap.addString(type, value)
+    var heapId: Int? = null
+        private set
+
+    fun addToHeap() {
+        if(heapId==null)
+            heapId = ++heapIdSequence
     }
 }
 
+private var heapIdSequence = 0
+
+
 class ArrayLiteralValue(val type: DataType,     // only array types
                         val value: Array<Expression>,
                         initHeapId: Int? =null,
@@ -498,32 +493,9 @@ class ArrayLiteralValue(val type: DataType,     // only array types
         return null    // invalid type conversion from $this to $targettype
     }
 
-    fun addToHeap(heap: HeapValues) {
-        if (heapId != null)
-            return
-        else {
-            if(value.any {it is AddressOf }) {
-                val intArrayWithAddressOfs = value.map {
-                    when (it) {
-                        is AddressOf -> IntegerOrAddressOf(null, it)
-                        is NumericLiteralValue -> IntegerOrAddressOf(it.number.toInt(), null)
-                        else -> throw FatalAstException("invalid datatype in array")
-                    }
-                }
-                heapId = heap.addIntegerArray(type, intArrayWithAddressOfs.toTypedArray())
-            } else {
-                val valuesInArray = value.map { (it as? NumericLiteralValue)?.number }
-                if(null !in valuesInArray) {
-                    heapId = if (type == DataType.ARRAY_F) {
-                        val doubleArray = valuesInArray.map { it!!.toDouble() }.toDoubleArray()
-                        heap.addDoublesArray(doubleArray)
-                    } else {
-                        val integerArray = valuesInArray.map { it!!.toInt() }
-                        heap.addIntegerArray(type, integerArray.map { IntegerOrAddressOf(it, null) }.toTypedArray())
-                    }
-                }
-            }
-        }
+    fun addToHeap() {
+        if(heapId==null)
+            heapId = ++heapIdSequence
     }
 }
 
@@ -608,7 +580,7 @@ internal fun makeRange(fromVal: Int, toVal: Int, stepVal: Int): IntProgression {
     }
 }
 
-class RegisterExpr(val register: Register, override val position: Position) : Expression() {
+class RegisterExpr(val register: Register, override val position: Position) : Expression(), IAssignable {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
@@ -626,7 +598,7 @@ class RegisterExpr(val register: Register, override val position: Position) : Ex
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.UBYTE)
 }
 
-data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : Expression() {
+data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : Expression(), IAssignable {
     override lateinit var parent: Node
 
     fun targetStatement(namespace: INameScope) =

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

@@ -1,12 +1,12 @@
 package prog8.ast.expressions
 
 import prog8.ast.base.DataType
+import java.util.*
 
 object InferredTypes {
     class InferredType private constructor(val isUnknown: Boolean, val isVoid: Boolean, private var datatype: DataType?) {
         init {
-            if(datatype!=null && (isUnknown || isVoid))
-                throw IllegalArgumentException("invalid combination of args")
+            require(!(datatype!=null && (isUnknown || isVoid))) { "invalid combination of args" }
         }
 
         val isKnown = datatype!=null
@@ -29,9 +29,11 @@ object InferredTypes {
             return when {
                 datatype!=null -> datatype.toString()
                 isVoid -> "<void>"
-                else -> "<unkonwn>"
+                else -> "<unknown>"
             }
         }
+
+        override fun hashCode(): Int = Objects.hash(isVoid, datatype)
     }
 
     private val unknownInstance = InferredType.unknown()

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

@@ -1,3 +1,5 @@
+@file:Suppress("DuplicatedCode")
+
 package prog8.ast.processing
 
 import prog8.ast.IFunctionCall
@@ -145,6 +147,7 @@ internal class AstChecker(private val program: Program,
                                 checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position))
                         }
                         DataType.BYTE -> {
+                            // TODO fix this, it should allow:  for bb in [1,2,3]
                             if(iterableDt!= DataType.BYTE && iterableDt!= DataType.ARRAY_B)
                                 checkResult.add(ExpressionError("byte loop variable can only loop over bytes", forLoop.position))
                         }
@@ -889,7 +892,7 @@ internal class AstChecker(private val program: Program,
                 for (arg in args.withIndex().zip(target.parameters)) {
                     val argIDt = arg.first.value.inferType(program)
                     if(!argIDt.isKnown) {
-                        throw FatalAstException("can't determine arg dt ${arg.first.value}")
+                        return
                     }
                     val argDt=argIDt.typeOrElse(DataType.STRUCT)
                     if(!(argDt isAssignableTo arg.second.type)) {
@@ -945,9 +948,8 @@ internal class AstChecker(private val program: Program,
                 if(dt !in NumericDatatypes && dt !in ArrayDatatypes)
                     checkResult.add(SyntaxError("can only increment or decrement a byte/float/word", postIncrDecr.position))
             }
-        } else if(postIncrDecr.target.memoryAddress != null) {
-            // a memory location can always be ++/--
         }
+        // else if(postIncrDecr.target.memoryAddress != null) { } // a memory location can always be ++/--
         super.visit(postIncrDecr)
     }
 
@@ -965,8 +967,7 @@ internal class AstChecker(private val program: Program,
             } else if(target.datatype in StringDatatypes) {
                 if(target.value is StringLiteralValue) {
                     // check string lengths for non-memory mapped strings
-                    val heapId = (target.value as StringLiteralValue).heapId!!
-                    val stringLen = program.heap.get(heapId).str!!.length
+                    val stringLen = (target.value as StringLiteralValue).value.length
                     val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
                     if (index != null && (index < 0 || index >= stringLen))
                         checkResult.add(ExpressionError("index out of bounds", arrayIndexedExpression.arrayspec.position))
@@ -1206,53 +1207,56 @@ internal class AstChecker(private val program: Program,
     }
 
     private fun checkArrayValues(value: ArrayLiteralValue, type: DataType): Boolean {
-        if(value.heapId==null) {
+        if (value.heapId == null) {
             // hmm weird, array literal that hasn't been moved to the heap yet?
             val array = value.value.mapNotNull { it.constValue(program) }
             val correct: Boolean
-            when(type) {
+            when (type) {
                 DataType.ARRAY_UB -> {
-                    correct=array.all { it.type==DataType.UBYTE && it.number.toInt() in 0..255 }
+                    correct = array.all { it.type == DataType.UBYTE && it.number.toInt() in 0..255 }
                 }
                 DataType.ARRAY_B -> {
-                    correct=array.all { it.type==DataType.BYTE && it.number.toInt() in -128..127 }
+                    correct = array.all { it.type == DataType.BYTE && it.number.toInt() in -128..127 }
                 }
                 DataType.ARRAY_UW -> {
-                    correct=array.all { it.type==DataType.UWORD && it.number.toInt() in 0..65535 }
+                    correct = array.all { it.type == DataType.UWORD && it.number.toInt() in 0..65535 }
                 }
                 DataType.ARRAY_W -> {
-                    correct=array.all { it.type==DataType.WORD && it.number.toInt() in -32768..32767}
+                    correct = array.all { it.type == DataType.WORD && it.number.toInt() in -32768..32767 }
                 }
                 DataType.ARRAY_F -> correct = true
                 else -> throw AstException("invalid array type $type")
             }
-            if(!correct)
+            if (!correct)
                 checkResult.add(ExpressionError("array value out of range for type $type", value.position))
             return correct
         }
 
-        val array = program.heap.get(value.heapId!!)
-        if(array.type !in ArrayDatatypes || (array.array==null && array.doubleArray==null))
-            throw FatalAstException("should have an array in the heapvar $array")
-
+        val array = value.value.map {
+            when (it) {
+                is NumericLiteralValue -> it.number.toInt()
+                is AddressOf -> it.identifier.heapId(program.namespace)
+                else -> -9999999
+            }
+        }
         val correct: Boolean
-        when(type) {
+        when (type) {
             DataType.ARRAY_UB -> {
-                correct= array.array?.all { it.integer!=null && it.integer in 0..255 } ?: false
+                correct = array.all { it in 0..255 }
             }
             DataType.ARRAY_B -> {
-                correct=array.array?.all { it.integer!=null && it.integer in -128..127 } ?: false
+                correct = array.all { it in -128..127 }
             }
             DataType.ARRAY_UW -> {
-                correct=array.array?.all { (it.integer!=null && it.integer in 0..65535)  || it.addressOf!=null} ?: false
+                correct = array.all { (it in 0..65535) }
             }
             DataType.ARRAY_W -> {
-                correct=array.array?.all { it.integer!=null && it.integer in -32768..32767 } ?: false
+                correct = array.all { it in -32768..32767 }
             }
-            DataType.ARRAY_F -> correct = array.doubleArray!=null
+            DataType.ARRAY_F -> correct = true
             else -> throw AstException("invalid array type $type")
         }
-        if(!correct)
+        if (!correct)
             checkResult.add(ExpressionError("array value out of range for type $type", value.position))
         return correct
     }

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

@@ -219,15 +219,8 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             val subroutine = returnStmt.definingSubroutine()!!
             if(subroutine.returntypes.size!=1)
                 return returnStmt  // mismatch in number of return values, error will be printed later.
-            val newValue: Expression
             val lval = returnStmt.value as? NumericLiteralValue
-            if(lval!=null) {
-                newValue = lval.cast(subroutine.returntypes.single())
-            } else {
-                newValue = returnStmt.value!!
-            }
-
-            returnStmt.value = newValue
+            returnStmt.value = lval?.cast(subroutine.returntypes.single()) ?: returnStmt.value!!
         }
         return super.visit(returnStmt)
     }
@@ -236,18 +229,19 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         val array = super.visit(arrayLiteral)
         if(array is ArrayLiteralValue) {
             val vardecl = array.parent as? VarDecl
-            return if (vardecl!=null) {
-                fixupArrayDatatype(array, vardecl, program)
-            } else if(array.heapId!=null) {
-                // fix the datatype of the array (also on the heap) to the 'biggest' datatype in the array
-                // (we don't know the desired datatype here exactly so we guess)
-                val datatype = determineArrayDt(array.value)
-                val litval2 = array.cast(datatype)!!
-                litval2.parent = array.parent
-                // finally, replace the literal array by a identifier reference.
-                makeIdentifierFromRefLv(litval2)
-            } else
-                array
+            return when {
+                vardecl!=null -> fixupArrayDatatype(array, vardecl, program)
+                array.heapId!=null -> {
+                    // fix the datatype of the array (also on the heap) to the 'biggest' datatype in the array
+                    // (we don't know the desired datatype here exactly so we guess)
+                    val datatype = determineArrayDt(array.value)
+                    val litval2 = array.cast(datatype)!!
+                    litval2.parent = array.parent
+                    // finally, replace the literal array by a identifier reference.
+                    makeIdentifierFromRefLv(litval2)
+                }
+                else -> array
+            }
         }
         return array
     }
@@ -260,7 +254,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             if (string.value.length !in 1..255)
                 checkResult.add(ExpressionError("string literal length must be between 1 and 255", string.position))
             else {
-                string.addToHeap(program.heap)
+                string.addToHeap()
             }
             return if (vardecl != null)
                 string
@@ -272,8 +266,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     private fun determineArrayDt(array: Array<Expression>): DataType {
         val datatypesInArray = array.map { it.inferType(program) }
-        if(datatypesInArray.isEmpty() || datatypesInArray.any { !it.isKnown })
-            throw IllegalArgumentException("can't determine type of empty array")
+        require(datatypesInArray.isNotEmpty() && datatypesInArray.all { it.isKnown }) { "can't determine type of empty array" }
         val dts = datatypesInArray.map { it.typeOrElse(DataType.STRUCT) }
         return when {
             DataType.FLOAT in dts -> DataType.ARRAY_F
@@ -289,7 +282,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         // a referencetype literal value that's not declared as a variable
         // we need to introduce an auto-generated variable for this to be able to refer to the value
         // note: if the var references the same literal value, it is not yet de-duplicated here.
-        array.addToHeap(program.heap)
+        array.addToHeap()
         val scope = array.definingScope()
         val variable = VarDecl.createAuto(array)
         return replaceWithIdentifier(variable, scope, array.parent)
@@ -299,7 +292,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         // a referencetype literal value that's not declared as a variable
         // we need to introduce an auto-generated variable for this to be able to refer to the value
         // note: if the var references the same literal value, it is not yet de-duplicated here.
-        string.addToHeap(program.heap)
+        string.addToHeap()
         val scope = string.definingScope()
         val variable = VarDecl.createAuto(string)
         return replaceWithIdentifier(variable, scope, string.parent)
@@ -340,14 +333,14 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
                 // repeat a string a number of times
                 val idt = string.inferType(program)
                 return StringLiteralValue(idt.typeOrElse(DataType.STR),
-                        string.value.repeat(constvalue.number.toInt()), null, expr.position)
+                        string.value.repeat(constvalue.number.toInt()), expr.position)
             }
         }
         if(expr.operator == "+" && operand is StringLiteralValue) {
             // concatenate two strings
             val idt = string.inferType(program)
             return StringLiteralValue(idt.typeOrElse(DataType.STR),
-                    "${string.value}${operand.value}", null, expr.position)
+                    "${string.value}${operand.value}", expr.position)
         }
         return expr
     }
@@ -426,7 +419,7 @@ internal fun fixupArrayDatatype(array: ArrayLiteralValue, vardecl: VarDecl, prog
                     }
             vardecl.value = litval2
             litval2.linkParents(vardecl)
-            litval2.addToHeap(program.heap)
+            litval2.addToHeap()
             return litval2
         }
     }

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

@@ -142,8 +142,7 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(forLoop: ForLoop): Statement {
-        val newloopvar = forLoop.loopVar?.accept(this)
-        when(newloopvar) {
+        when(val newloopvar = forLoop.loopVar?.accept(this)) {
             is IdentifierReference -> forLoop.loopVar = newloopvar
             null -> forLoop.loopVar = null
             else -> throw FatalAstException("can't change class of loopvar")
@@ -179,8 +178,7 @@ interface IAstModifyingVisitor {
     }
 
     fun visit(assignTarget: AssignTarget): AssignTarget {
-        val ident = assignTarget.identifier?.accept(this)
-        when (ident) {
+        when (val ident = assignTarget.identifier?.accept(this)) {
             is IdentifierReference -> assignTarget.identifier = ident
             null -> assignTarget.identifier = null
             else -> throw FatalAstException("can't change class of assign target identifier")

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

@@ -5,7 +5,6 @@ import prog8.ast.base.DataType
 import prog8.ast.base.FatalAstException
 import prog8.ast.base.initvarsSubName
 import prog8.ast.expressions.*
-import prog8.ast.mangledStructMemberName
 import prog8.ast.statements.*
 
 

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

@@ -45,7 +45,7 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA
             val array = ArrayLiteralValue(decl.datatype,
                     Array(arraysize) { NumericLiteralValue.optimalInteger(0, decl.position) },
                     null, decl.position)
-            array.addToHeap(program.heap)
+            array.addToHeap()
             decl.value = array
         }
 

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

@@ -37,7 +37,6 @@ sealed class Statement : Node {
     }
 }
 
-
 class BuiltinFunctionStatementPlaceholder(val name: String, override val position: Position) : Statement() {
     override var parent: Node = ParentSentinel
     override fun linkParents(parent: Node) {}
@@ -47,10 +46,8 @@ class BuiltinFunctionStatementPlaceholder(val name: String, override val positio
     override val expensiveToInline = false
 }
 
-
 data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean)
 
-
 class Block(override val name: String,
             val address: Int?,
             override var statements: MutableList<Statement>,
@@ -792,4 +789,3 @@ class DirectMemoryWrite(var addressExpression: Expression, override val position
     fun accept(visitor: IAstVisitor) = visitor.visit(this)
     fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
 }
-

compiler/src/prog8/compiler/Compiler.kt

@@ -1,13 +1,8 @@
 package prog8.compiler
 
-import prog8.ast.base.ArrayDatatypes
-import prog8.ast.base.DataType
-import prog8.ast.base.StringDatatypes
-import prog8.ast.expressions.AddressOf
 import java.io.File
 import java.io.InputStream
 import java.nio.file.Path
-import java.util.*
 import kotlin.math.abs
 
 enum class OutputType {
@@ -28,8 +23,6 @@ enum class ZeropageType {
     DONTUSE
 }
 
-data class IntegerOrAddressOf(val integer: Int?, val addressOf: AddressOf?)
-
 data class CompilationOptions(val output: OutputType,
                               val launcher: LauncherType,
                               val zeropage: ZeropageType,
@@ -73,77 +66,3 @@ fun loadAsmIncludeFile(filename: String, source: Path): String {
 internal fun tryGetEmbeddedResource(name: String): InputStream? {
     return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
 }
-
-class HeapValues {
-    data class HeapValue(val type: DataType, val str: String?, val array: Array<IntegerOrAddressOf>?, val doubleArray: DoubleArray?) {
-        override fun equals(other: Any?): Boolean {
-            if (this === other) return true
-            if (javaClass != other?.javaClass) return false
-            other as HeapValue
-            return type==other.type && str==other.str && Arrays.equals(array, other.array) && Arrays.equals(doubleArray, other.doubleArray)
-        }
-
-        override fun hashCode(): Int = Objects.hash(str, array, doubleArray)
-
-        val arraysize: Int = array?.size ?: doubleArray?.size ?: 0
-    }
-
-    private val heap = mutableMapOf<Int, HeapValue>()
-    private var heapId = 1
-
-    fun size(): Int = heap.size
-
-    fun addString(type: DataType, str: String): Int {
-        if (str.length > 255)
-            throw IllegalArgumentException("string length must be 0-255")
-
-        // strings are 'interned' and shared if they're the isSameAs
-        val value = HeapValue(type, str, null, null)
-
-        val existing = heap.filter { it.value==value }.map { it.key }.firstOrNull()
-        if(existing!=null)
-            return existing
-        val newId = heapId++
-        heap[newId] = value
-        return newId
-    }
-
-    fun addIntegerArray(type: DataType, array: Array<IntegerOrAddressOf>): Int {
-        // arrays are never shared, don't check for existing
-        if(type !in ArrayDatatypes)
-            throw CompilerException("wrong array type")
-        val newId = heapId++
-        heap[newId] = HeapValue(type, null, array, null)
-        return newId
-    }
-
-    fun addDoublesArray(darray: DoubleArray): Int {
-        // arrays are never shared, don't check for existing
-        val newId = heapId++
-        heap[newId] = HeapValue(DataType.ARRAY_F, null, null, darray)
-        return newId
-    }
-
-    fun update(heapId: Int, str: String) {
-        val oldVal = heap[heapId] ?: throw IllegalArgumentException("heapId not found in heap")
-        if(oldVal.type in StringDatatypes) {
-            if (oldVal.str!!.length != str.length)
-                throw IllegalArgumentException("heap string length mismatch")
-            heap[heapId] = oldVal.copy(str = str)
-        }
-        else throw IllegalArgumentException("heap data type mismatch")
-    }
-
-    fun update(heapId: Int, heapval: HeapValue) {
-        if(heapId !in heap)
-            throw IllegalArgumentException("heapId not found in heap")
-        heap[heapId] = heapval
-    }
-
-    fun get(heapId: Int): HeapValue {
-        return heap[heapId] ?:
-        throw IllegalArgumentException("heapId $heapId not found in heap")
-    }
-
-    fun allEntries() = heap.entries
-}

compiler/src/prog8/compiler/Main.kt

@@ -25,7 +25,8 @@ class CompilationResult(val success: Boolean,
 
 fun compileProgram(filepath: Path,
                    optimize: Boolean,
-                   writeAssembly: Boolean): CompilationResult {
+                   writeAssembly: Boolean,
+                   outputDir: Path): CompilationResult {
     lateinit var programAst: Program
     var programName: String? = null
 
@@ -102,7 +103,7 @@ fun compileProgram(filepath: Path,
                 // asm generation directly from the Ast, no need for intermediate code
                 val zeropage = MachineDefinition.C64Zeropage(compilerOptions)
                 programAst.anonscopeVarsCleanup()
-                val assembly = AsmGen(programAst, compilerOptions, zeropage).compileToAssembly(optimize)
+                val assembly = AsmGen(programAst, compilerOptions, zeropage, outputDir).compileToAssembly(optimize)
                 assembly.assemble(compilerOptions)
                 programName = assembly.name
             }

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

@@ -2,12 +2,14 @@ package prog8.compiler.target.c64
 
 import prog8.compiler.CompilationOptions
 import prog8.compiler.OutputType
-import java.io.File
+import java.nio.file.Path
 import kotlin.system.exitProcess
 
-class AssemblyProgram(val name: String) {
-    private val assemblyFile = "$name.asm"
-    private val viceMonListFile = "$name.vice-mon-list"
+class AssemblyProgram(val name: String, val outputDir: Path) {
+    private val assemblyFile = outputDir.resolve("$name.asm")
+    private val prgFile = outputDir.resolve("$name.prg")
+    private val binFile = outputDir.resolve("$name.bin")
+    private val viceMonListFile = outputDir.resolve("$name.vice-mon-list")
 
     companion object {
         // 6502 opcodes (including aliases and illegal opcodes), these cannot be used as variable or label names
@@ -27,21 +29,21 @@ class AssemblyProgram(val name: String) {
         // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps
         val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
                 "-Wall", "-Wno-strict-bool", "-Wno-shadow", "-Werror", "-Wno-error=long-branch",
-                "--dump-labels", "--vice-labels", "-l", viceMonListFile, "--no-monitor")
+                "--dump-labels", "--vice-labels", "-l", viceMonListFile.toString(), "--no-monitor")
 
         val outFile = when(options.output) {
             OutputType.PRG -> {
                 command.add("--cbm-prg")
                 println("\nCreating C-64 prg.")
-                "$name.prg"
+                prgFile
             }
             OutputType.RAW -> {
                 command.add("--nostart")
                 println("\nCreating raw binary.")
-                "$name.bin"
+                binFile
             }
         }
-        command.addAll(listOf("--output", outFile, assemblyFile))
+        command.addAll(listOf("--output", outFile.toString(), assemblyFile.toString()))
 
         val proc = ProcessBuilder(command).inheritIO().start()
         val result = proc.waitFor()
@@ -57,7 +59,7 @@ class AssemblyProgram(val name: String) {
         // builds list of breakpoints, appends to monitor list file
         val breakpoints = mutableListOf<String>()
         val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that"s generated for them
-        for(line in File(viceMonListFile).readLines()) {
+        for(line in viceMonListFile.toFile().readLines()) {
             val match = pattern.matchEntire(line)
             if(match!=null)
             breakpoints.add("break \$" + match.groupValues[1])
@@ -66,6 +68,6 @@ class AssemblyProgram(val name: String) {
         breakpoints.add(0, "; vice monitor breakpoint list now follows")
         breakpoints.add(1, "; $num breakpoints have been defined")
         breakpoints.add(2, "del")
-        File(viceMonListFile).appendText(breakpoints.joinToString("\n")+"\n")
+        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n")+"\n")
     }
 }

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

@@ -14,8 +14,8 @@ import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.Petscii
 import prog8.functions.BuiltinFunctions
 import prog8.functions.FunctionSignature
-import java.io.File
 import java.math.RoundingMode
+import java.nio.file.Path
 import java.util.*
 import kotlin.math.absoluteValue
 
@@ -25,7 +25,8 @@ internal class AssemblyError(msg: String) : RuntimeException(msg)
 
 internal class AsmGen(val program: Program,
                       val options: CompilationOptions,
-                      val zeropage: Zeropage) {
+                      val zeropage: Zeropage,
+                      val outputDir: Path) {
 
     private val assemblyLines = mutableListOf<String>()
     private val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
@@ -62,11 +63,12 @@ internal class AsmGen(val program: Program,
             }
         }
 
-        File("${program.name}.asm").printWriter().use {
+        val outputFile = outputDir.resolve("${program.name}.asm").toFile()
+        outputFile.printWriter().use {
             for (line in assemblyLines) { it.println(line) }
         }
 
-        return AssemblyProgram(program.name)
+        return AssemblyProgram(program.name, outputDir)
     }
 
     private fun header() {
@@ -820,8 +822,7 @@ internal class AsmGen(val program: Program,
     }
 
     internal fun translateArrayIndexIntoA(expr: ArrayIndexedExpression) {
-        val index = expr.arrayspec.index
-        when (index) {
+        when (val index = expr.arrayspec.index) {
             is NumericLiteralValue -> throw AssemblyError("this should be optimized directly")
             is RegisterExpr -> {
                 when (index.register) {

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

@@ -101,7 +101,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
 
     // optimize sequential assignments of the isSameAs value to various targets (bytes, words, floats)
     // the float one is the one that requires 2*7=14 lines of code to check...
-    // @todo a better place to do this is in the Compiler instead and transform the Ast, and never even create the inefficient asm in the first place...
+    // @todo a better place to do this is in the Compiler instead and transform the Ast, or the AsmGen, and never even create the inefficient asm in the first place...
 
     val removeLines = mutableListOf<Int>()
     for (pair in linesByFourteen) {

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

@@ -9,7 +9,6 @@ import prog8.ast.base.WordDatatypes
 import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.FunctionCallStatement
-import prog8.compiler.target.c64.MachineDefinition
 import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS1_HEX
@@ -122,24 +121,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 translateFunctionArguments(fcall.arglist, func)
                 asmgen.out("  jsr  c64flt.func_$functionName")
             }
-/*
-        TODO this was the old code for bit rotations:
-            Opcode.SHL_BYTE -> AsmFragment(" asl  $variable+$index", 8)
-            Opcode.SHR_UBYTE -> AsmFragment(" lsr  $variable+$index", 8)
-            Opcode.SHR_SBYTE -> AsmFragment(" lda  $variable+$index |  asl  a |  ror  $variable+$index")
-            Opcode.SHL_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
-            Opcode.SHR_UWORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
-            Opcode.SHR_SWORD -> AsmFragment(" lda  $variable+${index * 2 + 1} |  asl  a |  ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
-            Opcode.ROL_BYTE -> AsmFragment(" rol  $variable+$index", 8)
-            Opcode.ROR_BYTE -> AsmFragment(" ror  $variable+$index", 8)
-            Opcode.ROL_WORD -> AsmFragment(" rol  $variable+${index * 2 + 1} |  rol  $variable+${index * 2}", 8)
-            Opcode.ROR_WORD -> AsmFragment(" ror  $variable+${index * 2 + 1} |  ror  $variable+${index * 2}", 8)
-            Opcode.ROL2_BYTE -> AsmFragment(" lda  $variable+$index |  cmp  #\$80 |  rol  $variable+$index", 8)
-            Opcode.ROR2_BYTE -> AsmFragment(" lda  $variable+$index |  lsr  a |  bcc  + |  ora  #\$80 |+ |  sta  $variable+$index", 10)
-            Opcode.ROL2_WORD -> AsmFragment(" asl  $variable+${index * 2 + 1} |  rol  $variable+${index * 2} |  bcc  + |  inc  $variable+${index * 2 + 1} |+", 20)
-            Opcode.ROR2_WORD -> AsmFragment(" lsr  $variable+${index * 2 + 1} |  ror  $variable+${index * 2} |  bcc  + |  lda  $variable+${index * 2 + 1} |  ora  #\$80 |  sta  $variable+${index * 2 + 1} |+", 30)
-
- */
             "lsl" -> {
                 // in-place
                 val what = fcall.arglist.single()
@@ -157,20 +138,35 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             is IdentifierReference -> asmgen.out("  asl  ${asmgen.asmIdentifierName(what)}")
                             is DirectMemoryRead -> {
                                 if (what.addressExpression is NumericLiteralValue) {
-                                    asmgen.out("  asl  ${(what.addressExpression as NumericLiteralValue).number.toHex()}")
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  asl  ${number.toHex()}")
                                 } else {
-                                    TODO("lsl memory byte $what")
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("""
+                    inx
+                    lda  $ESTACK_LO_HEX,x
+                    sta  (+) + 1
+                    lda  $ESTACK_HI_HEX,x
+                    sta  (+) + 2
++                   asl  0            ; modified                    
+                                    """)
                                 }
                             }
                             is ArrayIndexedExpression -> {
-                                TODO("lsl byte array $what")
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsl_array_b")
                             }
                             else -> throw AssemblyError("weird type")
                         }
                     }
                     in WordDatatypes -> {
                         when (what) {
-                            is ArrayIndexedExpression -> TODO("lsl sbyte $what")
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsl_array_w")
+                            }
                             is IdentifierReference -> {
                                 val variable = asmgen.asmIdentifierName(what)
                                 asmgen.out(" asl  $variable |  rol  $variable+1")
@@ -198,22 +194,35 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             is IdentifierReference -> asmgen.out("  lsr  ${asmgen.asmIdentifierName(what)}")
                             is DirectMemoryRead -> {
                                 if (what.addressExpression is NumericLiteralValue) {
-                                    asmgen.out("  lsr  ${(what.addressExpression as NumericLiteralValue).number.toHex()}")
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  lsr  ${number.toHex()}")
                                 } else {
-                                    TODO("lsr memory byte $what")
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("""
+                    inx
+                    lda  $ESTACK_LO_HEX,x
+                    sta  (+) + 1
+                    lda  $ESTACK_HI_HEX,x
+                    sta  (+) + 2
++                   lsr  0            ; modified                    
+                                    """)
                                 }
                             }
                             is ArrayIndexedExpression -> {
-                                TODO("lsr byte array $what")
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsr_array_ub")
                             }
                             else -> throw AssemblyError("weird type")
                         }
                     }
                     DataType.BYTE -> {
                         when (what) {
-                            is ArrayIndexedExpression -> TODO("lsr sbyte $what")
-                            is DirectMemoryRead -> TODO("lsr sbyte $what")
-                            is RegisterExpr -> TODO("lsr sbyte $what")
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsr_array_b")
+                            }
                             is IdentifierReference -> {
                                 val variable = asmgen.asmIdentifierName(what)
                                 asmgen.out("  lda  $variable |  asl  a |  ror  $variable")
@@ -223,7 +232,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     }
                     DataType.UWORD -> {
                         when (what) {
-                            is ArrayIndexedExpression -> TODO("lsr uword $what")
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsr_array_uw")
+                            }
                             is IdentifierReference -> {
                                 val variable = asmgen.asmIdentifierName(what)
                                 asmgen.out(" lsr  $variable+1 |  ror  $variable")
@@ -233,7 +246,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     }
                     DataType.WORD -> {
                         when (what) {
-                            is ArrayIndexedExpression -> TODO("lsr sword $what")
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.lsr_array_w")
+                            }
                             is IdentifierReference -> {
                                 val variable = asmgen.asmIdentifierName(what)
                                 asmgen.out("  lda  $variable+1 |  asl a  |  ror  $variable+1 |  ror  $variable")
@@ -250,10 +267,55 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 val dt = what.inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
                     DataType.UBYTE -> {
-                        TODO("rol ubyte")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.rol_array_ub")
+                            }
+                            is DirectMemoryRead -> {
+                                if (what.addressExpression is NumericLiteralValue) {
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  rol  ${number.toHex()}")
+                                } else {
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("""
+                    inx
+                    lda  $ESTACK_LO_HEX,x
+                    sta  (+) + 1
+                    lda  $ESTACK_HI_HEX,x
+                    sta  (+) + 2
++                   rol  0            ; modified                    
+                                    """)
+                                }
+                            }
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  rol  a")
+                                    Register.X -> asmgen.out("  txa |  rol  a |  tax")
+                                    Register.Y -> asmgen.out("  tya |  rol  a |  tay")
+                                }
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  rol  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     DataType.UWORD -> {
-                        TODO("rol uword")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.rol_array_uw")
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  rol  $variable |  rol  $variable+1")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     else -> throw AssemblyError("weird type")
                 }
@@ -264,10 +326,48 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 val dt = what.inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
                     DataType.UBYTE -> {
-                        TODO("rol2 ubyte")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.rol2_array_ub")
+                            }
+                            is DirectMemoryRead -> {
+                                if (what.addressExpression is NumericLiteralValue) {
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  lda  ${number.toHex()} |  cmp  #\$80 |  rol  a |  sta  ${number.toHex()}")
+                                } else {
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("  jsr  prog8_lib.rol2_mem_ub")
+                                }
+                            }
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  cmp  #\$80 |  rol  a  ")
+                                    Register.X -> asmgen.out("  txa  |  cmp  #\$80 |  rol  a  |  tax")
+                                    Register.Y -> asmgen.out("  tya  |  cmp  #\$80 |  rol  a  |  tay")
+                                }
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  lda  $variable |  cmp  #\$80 |  rol  a |  sta  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     DataType.UWORD -> {
-                        TODO("rol2 uword")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.rol2_array_uw")
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  asl  $variable |  rol  $variable+1 |  bcc  + |  inc  $variable |+  ")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     else -> throw AssemblyError("weird type")
                 }
@@ -278,10 +378,54 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 val dt = what.inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
                     DataType.UBYTE -> {
-                        TODO("ror ubyte")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.ror_array_ub")
+                            }
+                            is DirectMemoryRead -> {
+                                if (what.addressExpression is NumericLiteralValue) {
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  ror  ${number.toHex()}")
+                                } else {
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("""
+                    inx
+                    lda  $ESTACK_LO_HEX,x
+                    sta  (+) + 1
+                    lda  $ESTACK_HI_HEX,x
+                    sta  (+) + 2
++                   ror  0            ; modified                    
+                                    """)                                }
+                            }
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  ror  a")
+                                    Register.X -> asmgen.out("  txa |  ror  a |  tax")
+                                    Register.Y -> asmgen.out("  tya |  ror  a |  tay")
+                                }
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  ror  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     DataType.UWORD -> {
-                        TODO("ror uword")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.ror_array_uw")
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  ror  $variable+1 |  ror  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     else -> throw AssemblyError("weird type")
                 }
@@ -292,10 +436,48 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 val dt = what.inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
                     DataType.UBYTE -> {
-                        TODO("ror2 ubyte")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.ror2_array_ub")
+                            }
+                            is DirectMemoryRead -> {
+                                if (what.addressExpression is NumericLiteralValue) {
+                                    val number = (what.addressExpression as NumericLiteralValue).number
+                                    asmgen.out("  lda  ${number.toHex()} |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  ${number.toHex()}")
+                                } else {
+                                    asmgen.translateExpression(what.addressExpression)
+                                    asmgen.out("  jsr  prog8_lib.ror2_mem_ub")
+                                }
+                            }
+                            is RegisterExpr -> {
+                                when(what.register) {
+                                    Register.A -> asmgen.out("  lsr  a |  bcc  + |  ora  #\$80 |+  ")
+                                    Register.X -> asmgen.out("  txa |  lsr  a |  bcc  + |  ora  #\$80 |+  tax ")
+                                    Register.Y -> asmgen.out("  tya |  lsr  a |  bcc  + |  ora  #\$80 |+  tay ")
+                                }
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  lda  $variable |  lsr  a |  bcc  + |  ora  #\$80 |+  |  sta  $variable")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     DataType.UWORD -> {
-                        TODO("ror2 uword")
+                        when(what) {
+                            is ArrayIndexedExpression -> {
+                                asmgen.translateExpression(what.identifier)
+                                asmgen.translateExpression(what.arrayspec.index)
+                                asmgen.out("  jsr  prog8_lib.ror2_array_uw")
+                            }
+                            is IdentifierReference -> {
+                                val variable = asmgen.asmIdentifierName(what)
+                                asmgen.out("  lsr  $variable+1 |  ror  $variable |  bcc  + |  lda  $variable+1 |  ora  #\$80 |  sta  $variable+1 |+  ")
+                            }
+                            else -> throw AssemblyError("weird type")
+                        }
                     }
                     else -> throw AssemblyError("weird type")
                 }

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

@@ -164,10 +164,12 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             DataType.UBYTE, DataType.BYTE -> {
                 asmgen.out("  lda  $varname  |  sta  ${MachineDefinition.ESTACK_LO_HEX},x  |  dex")
             }
-            DataType.UWORD, DataType.WORD, in ArrayDatatypes, in StringDatatypes -> {
-                // (for arrays and strings, push their address)
+            DataType.UWORD, DataType.WORD -> {
                 asmgen.out("  lda  $varname  |  sta  ${MachineDefinition.ESTACK_LO_HEX},x  |  lda  $varname+1 |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
             }
+            in ArrayDatatypes, in StringDatatypes -> {
+                asmgen.out("  lda  #<$varname  |  sta  ${MachineDefinition.ESTACK_LO_HEX},x  |  lda  #>$varname |  sta  ${MachineDefinition.ESTACK_HI_HEX},x |  dex")
+            }
             DataType.FLOAT -> {
                 asmgen.out(" lda  #<$varname |  ldy  #>$varname|  jsr  c64flt.push_float")
             }

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

@@ -8,10 +8,15 @@ import prog8.ast.expressions.RangeExpr
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.ForLoop
-import prog8.compiler.target.c64.MachineDefinition
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.toHex
 import kotlin.math.absoluteValue
 
+// todo choose more efficient comparisons to avoid needless lda's
+// todo optimize common case step == 2 / -2
+
 
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
@@ -25,8 +30,6 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
                 if(range==null) {
                     translateForOverNonconstRange(stmt, iterableDt.typeOrElse(DataType.STRUCT), stmt.iterable as RangeExpr)
                 } else {
-                    if (range.isEmpty())
-                        throw AssemblyError("empty range")
                     translateForOverConstRange(stmt, iterableDt.typeOrElse(DataType.STRUCT), range)
                 }
             }
@@ -41,68 +44,132 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
         val continueLabel = asmgen.makeLabel("for_continue")
-        val counterLabel = asmgen.makeLabel("for_counter")
         asmgen.loopEndLabels.push(endLabel)
         asmgen.loopContinueLabels.push(continueLabel)
-        val stepsize=range.step.constValue(program)?.number
-        when (stepsize) {
-            1 -> {
-                when(iterableDt) {
-                    DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                        if (stmt.loopRegister != null) {
-                            // loop register over range
-                            if(stmt.loopRegister!= Register.A)
-                                throw AssemblyError("can only use A")
-                            asmgen.translateExpression(range.to)
-                            asmgen.translateExpression(range.from)
-                            asmgen.out("""
+        val stepsize=range.step.constValue(program)!!.number.toInt()
+        when(iterableDt) {
+            DataType.ARRAY_B, DataType.ARRAY_UB -> {
+                if (stepsize==1 || stepsize==-1) {
+
+                    // bytes, step 1 or -1
+
+                    val incdec = if(stepsize==1) "inc" else "dec"
+                    if (stmt.loopRegister != null) {
+                        // loop register over range
+                        if(stmt.loopRegister!= Register.A)
+                            throw AssemblyError("can only use A")
+                        asmgen.translateExpression(range.to)
+                        asmgen.translateExpression(range.from)
+                        asmgen.out("""
                 inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                lda  ${ESTACK_LO_HEX},x
                 sta  $loopLabel+1
+$loopLabel      lda  #0                 ; modified""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  lda  $loopLabel+1
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                beq  $endLabel
+                $incdec  $loopLabel+1
+                jmp  $loopLabel
+$endLabel       inx""")
+                    } else {
+                        // loop over byte range via loopvar
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                        asmgen.translateExpression(range.to)
+                        asmgen.translateExpression(range.from)
+                        asmgen.out("""
+                inx
+                lda  ${ESTACK_LO_HEX},x
+                sta  $varname
+$loopLabel""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  lda  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                beq  $endLabel
+                $incdec  $varname
+                jmp  $loopLabel
+$endLabel       inx""")
+                    }
+                }
+                else {
+
+                    // bytes, step >= 2 or <= -2
+
+                    if (stmt.loopRegister != null) {
+                        // loop register over range
+                        if(stmt.loopRegister!= Register.A)
+                            throw AssemblyError("can only use A")
+                        asmgen.translateExpression(range.to)
+                        asmgen.translateExpression(range.from)
+                        asmgen.out("""
                 inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX},x
-                sec
-                sbc  $loopLabel+1
-                adc  #0
-                sta  $counterLabel
+                lda  ${ESTACK_LO_HEX},x
+                sta  $loopLabel+1
 $loopLabel      lda  #0                 ; modified""")
-                            asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  lda  $loopLabel+1""")
+                        if(stepsize>0) {
                             asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                inc  $loopLabel+1
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
+                clc
+                adc  #$stepsize
+                sta  $loopLabel+1
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcc  $loopLabel
+                beq  $loopLabel""")
                         } else {
-                            // loop over byte range via loopvar
-                            val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                            asmgen.translateExpression(range.to)
-                            asmgen.translateExpression(range.from)
                             asmgen.out("""
+                sec
+                sbc  #${stepsize.absoluteValue}
+                sta  $loopLabel+1
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcs  $loopLabel""")
+                        }
+                        asmgen.out("""
+$endLabel       inx""")
+                    } else {
+                        // loop over byte range via loopvar
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                        asmgen.translateExpression(range.to)
+                        asmgen.translateExpression(range.from)
+                        asmgen.out("""
                 inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX},x
+                lda  ${ESTACK_LO_HEX},x
                 sta  $varname
-                inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX},x
-                sec
-                sbc  $varname
-                adc  #0
-                sta  $counterLabel
 $loopLabel""")
-                            asmgen.translate(stmt.body)
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  lda  $varname""")
+                        if(stepsize>0) {
                             asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                inc  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
+                clc
+                adc  #$stepsize
+                sta  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcc  $loopLabel
+                beq  $loopLabel""")
+                        } else {
+                            asmgen.out("""
+                sec
+                sbc  #${stepsize.absoluteValue}
+                sta  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcs  $loopLabel""")
                         }
+                        asmgen.out("""
+$endLabel       inx""")
                     }
-                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                }
+            }
+            DataType.ARRAY_W, DataType.ARRAY_UW -> {
+                when {
+
+                    // words, step 1 or -1
+
+                    stepsize == 1 || stepsize == -1 -> {
                         asmgen.translateExpression(range.to)
-                        asmgen.out("  inc  ${MachineDefinition.ESTACK_LO_HEX}+1,x |  bne  + |  inc  ${MachineDefinition.ESTACK_HI_HEX}+1,x |+  ")
                         val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
                         val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
                                 null, range.from, range.position)
@@ -111,81 +178,34 @@ $endLabel""")
                         asmgen.out(loopLabel)
                         asmgen.translate(stmt.body)
                         asmgen.out("""
-                inc  $varname
+                lda  $varname+1
+                cmp  $ESTACK_HI_PLUS1_HEX,x
+                bne  +
+                lda  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                beq  $endLabel""")
+                        if(stepsize==1) {
+                            asmgen.out("""
++               inc  $varname
                 bne  +
                 inc  $varname+1            
-+               lda  ${MachineDefinition.ESTACK_HI_HEX}+1,x
-                cmp  $varname+1
+                            """)
+                        } else {
+                            asmgen.out("""
++               lda  $varname
                 bne  +
-                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
-                cmp  $varname
-                beq  $endLabel
+                dec  $varname+1
++               dec  $varname""")
+                        }
+                        asmgen.out("""
 +               jmp  $loopLabel
 $endLabel       inx""")
                     }
-                    else -> throw AssemblyError("range expression can only be byte or word")
-                }
-            }
-            -1 -> {
-                when(iterableDt){
-                    DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                        if (stmt.loopRegister != null) {
-                            // loop register over range
-                            if(stmt.loopRegister!= Register.A)
-                                throw AssemblyError("can only use A")
-                            asmgen.translateExpression(range.from)
-                            asmgen.translateExpression(range.to)
-                            asmgen.out("""
-                inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
-                sta  $loopLabel+1
-                sec
-                sbc  ${MachineDefinition.ESTACK_LO_HEX},x
-                adc  #0
-                sta  $counterLabel
-                inx
-$loopLabel      lda  #0                 ; modified""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                dec  $loopLabel+1
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        } else {
-                            // loop over byte range via loopvar
-                            val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
-                            asmgen.translateExpression(range.from)
-                            asmgen.translateExpression(range.to)
-                            asmgen.out("""
-                inx
-                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
-                sta  $varname
-                sec
-                sbc  ${MachineDefinition.ESTACK_LO_HEX},x
-                adc  #0
-                sta  $counterLabel
-                inx
-$loopLabel""")
-                            asmgen.translate(stmt.body)
-                            asmgen.out("""
-$continueLabel  dec  $counterLabel
-                beq  $endLabel
-                dec  $varname
-                jmp  $loopLabel
-$counterLabel   .byte  0                
-$endLabel""")
-                        }
-                    }
-                    DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                    stepsize > 0 -> {
+
+                        // (u)words, step >= 2
+
                         asmgen.translateExpression(range.to)
-                        asmgen.out("""
-                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
-                bne  +
-                dec  ${MachineDefinition.ESTACK_HI_HEX}+1,x
-+               dec  ${MachineDefinition.ESTACK_LO_HEX}+1,x                            
-                        """)
                         val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
                         val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
                                 null, range.from, range.position)
@@ -193,29 +213,97 @@ $endLabel""")
                         asmgen.translate(assignLoopvar)
                         asmgen.out(loopLabel)
                         asmgen.translate(stmt.body)
-                        asmgen.out("""
+
+                        if (iterableDt == DataType.ARRAY_UW) {
+                            asmgen.out("""
                 lda  $varname
-                bne  +
-                dec  $varname+1
-+               dec  $varname                
-                lda  ${MachineDefinition.ESTACK_HI_HEX}+1,x
+                clc
+                adc  #<$stepsize
+                sta  $varname
+                lda  $varname+1
+                adc  #>$stepsize
+                sta  $varname+1
+                lda  $ESTACK_HI_PLUS1_HEX,x
                 cmp  $varname+1
-                bne  +
-                lda  ${MachineDefinition.ESTACK_LO_HEX}+1,x
-                cmp  $varname
-                beq  $endLabel
-+               jmp  $loopLabel
+                bcc  $endLabel
+                bne  $loopLabel
+                lda  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcc  $endLabel
+                bcs  $loopLabel
 $endLabel       inx""")
+                        } else {
+                            asmgen.out("""
+                lda  $varname
+                clc
+                adc  #<$stepsize
+                sta  $varname
+                lda  $varname+1
+                adc  #>$stepsize
+                sta  $varname+1
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                cmp  $varname
+                lda  $ESTACK_HI_PLUS1_HEX,x
+                sbc  $varname+1
+                bvc  +
+                eor  #$80
++               bpl  $loopLabel                
+$endLabel       inx""")
+                        }
+                    }
+                    else -> {
+
+                        // (u)words, step <= -2
+                        asmgen.translateExpression(range.to)
+                        val varname = asmgen.asmIdentifierName(stmt.loopVar!!)
+                        val assignLoopvar = Assignment(AssignTarget(null, stmt.loopVar, null, null, stmt.loopVar!!.position),
+                                null, range.from, range.position)
+                        assignLoopvar.linkParents(stmt)
+                        asmgen.translate(assignLoopvar)
+                        asmgen.out(loopLabel)
+                        asmgen.translate(stmt.body)
+
+                        if(iterableDt==DataType.ARRAY_UW) {
+                            asmgen.out("""
+                lda  $varname
+                sec
+                sbc  #<${stepsize.absoluteValue}
+                sta  $varname
+                lda  $varname+1
+                sbc  #>${stepsize.absoluteValue}
+                sta  $varname+1
+                cmp  $ESTACK_HI_PLUS1_HEX,x
+                bcc  $endLabel
+                bne  $loopLabel
+                lda  $varname
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                bcs  $loopLabel
+$endLabel       inx""")
+                        } else {
+                            asmgen.out("""
+                lda  $varname
+                sec
+                sbc  #<${stepsize.absoluteValue}
+                sta  $varname
+                pha
+                lda  $varname+1
+                sbc  #>${stepsize.absoluteValue}
+                sta  $varname+1
+                pla
+                cmp  $ESTACK_LO_PLUS1_HEX,x
+                lda  $varname+1
+                sbc  $ESTACK_HI_PLUS1_HEX,x
+                bvc  +
+                eor  #$80
++               bpl  $loopLabel                
+$endLabel       inx""")
+                        }
                     }
-                    else -> throw AssemblyError("range expression can only be byte or word")
                 }
             }
-            else -> when (iterableDt) {
-                DataType.ARRAY_UB, DataType.ARRAY_B -> TODO("non-const forloop bytes, step >1: $stepsize")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> TODO("non-const forloop words, step >1: $stepsize")
-                else -> throw AssemblyError("range expression can only be byte or word")
-            }
+            else -> throw AssemblyError("range expression can only be byte or word")
         }
+
         asmgen.loopEndLabels.pop()
         asmgen.loopContinueLabels.pop()
     }
@@ -322,6 +410,8 @@ $endLabel""")
 
     private fun translateForOverConstRange(stmt: ForLoop, iterableDt: DataType, range: IntProgression) {
         // TODO: optimize loop code when the range is < 256 iterations, don't need a separate counter in such cases
+        if (range.isEmpty())
+            throw AssemblyError("empty range")
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
         val continueLabel = asmgen.makeLabel("for_continue")
@@ -544,11 +634,59 @@ $endLabel""")
                     }
                     range.step >= 2 -> {
                         // word, step >= 2
-                        TODO("for, word, step>=2")
+                        // note: range.last has already been adjusted by kotlin itself to actually be the last value of the sequence
+                        val lastValue = range.last+range.step
+                        asmgen.out("""
+                lda  #<${range.first}
+                ldy  #>${range.first}
+                sta  $varname
+                sty  $varname+1
+$loopLabel""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  clc
+                lda  $varname
+                adc  #<${range.step}
+                sta  $varname
+                lda  $varname+1
+                adc  #>${range.step}
+                sta  $varname+1
+                lda  $varname
+                cmp  #<$lastValue
+                bne  +
+                lda  $varname+1
+                cmp  #>$lastValue
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel""")
                     }
                     else -> {
                         // step <= -2
-                        TODO("for, word, step<=-2")
+                        // note: range.last has already been adjusted by kotlin itself to actually be the last value of the sequence
+                        val lastValue = range.last+range.step
+                        asmgen.out("""
+                lda  #<${range.first}
+                ldy  #>${range.first}
+                sta  $varname
+                sty  $varname+1
+$loopLabel""")
+                        asmgen.translate(stmt.body)
+                        asmgen.out("""
+$continueLabel  sec
+                lda  $varname
+                sbc  #<${range.step.absoluteValue}
+                sta  $varname
+                lda  $varname+1
+                sbc  #>${range.step.absoluteValue}
+                sta  $varname+1
+                lda  $varname
+                cmp  #<$lastValue
+                bne  +
+                lda  $varname+1
+                cmp  #>$lastValue
+                beq  $endLabel
++               jmp  $loopLabel
+$endLabel""")
                     }
                 }
             }

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

@@ -57,8 +57,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                 }
             }
             targetMemory!=null -> {
-                val addressExpr = targetMemory.addressExpression
-                when (addressExpr) {
+                when (val addressExpr = targetMemory.addressExpression) {
                     is NumericLiteralValue -> {
                         val what = addressExpr.number.toHex()
                         asmgen.out(if(incr) "  inc  $what" else "  dec  $what")

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -88,32 +88,7 @@ val BuiltinFunctions = mapOf(
                                                         BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
                                                         BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", StringDatatypes)), DataType.UBYTE, ::builtinStrlen),
-
-    // TODO clean up these vm-specific functions
-    "vm_write_memchr"  to FunctionSignature(false, listOf(BuiltinFunctionParam("address", setOf(DataType.UWORD))), null),
-    "vm_write_memstr"  to FunctionSignature(false, listOf(BuiltinFunctionParam("address", setOf(DataType.UWORD))), null),
-    "vm_write_num"     to FunctionSignature(false, listOf(BuiltinFunctionParam("number", NumericDatatypes)), null),
-    "vm_write_char"    to FunctionSignature(false, listOf(BuiltinFunctionParam("char", setOf(DataType.UBYTE))), null),
-    "vm_write_str"     to FunctionSignature(false, listOf(BuiltinFunctionParam("string", StringDatatypes)), null),
-    "vm_input_str"     to FunctionSignature(false, listOf(BuiltinFunctionParam("intovar", StringDatatypes)), null),
-    "vm_gfx_clearscr"  to FunctionSignature(false, listOf(BuiltinFunctionParam("color", setOf(DataType.UBYTE))), null),
-    "vm_gfx_pixel"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("x", IntegerDatatypes),
-                                                        BuiltinFunctionParam("y", IntegerDatatypes),
-                                                        BuiltinFunctionParam("color", IntegerDatatypes)), null),
-    "vm_gfx_line"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("x1", IntegerDatatypes),
-                                                        BuiltinFunctionParam("y1", IntegerDatatypes),
-                                                        BuiltinFunctionParam("x2", IntegerDatatypes),
-                                                        BuiltinFunctionParam("y2", IntegerDatatypes),
-                                                        BuiltinFunctionParam("color", IntegerDatatypes)), null),
-    "vm_gfx_text"      to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("x", IntegerDatatypes),
-                                                        BuiltinFunctionParam("y", IntegerDatatypes),
-                                                        BuiltinFunctionParam("color", IntegerDatatypes),
-                                                        BuiltinFunctionParam("text", StringDatatypes)),
-                                                        null)
+    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", StringDatatypes)), DataType.UBYTE, ::builtinStrlen)
 )
 
 fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
@@ -145,8 +120,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
             val idt = arglist.inferType(program)
             if(!idt.isKnown)
                 throw FatalAstException("couldn't determine type of iterable $arglist")
-            val dt = idt.typeOrElse(DataType.STRUCT)
-            return when(dt) {
+            return when(val dt = idt.typeOrElse(DataType.STRUCT)) {
                 in NumericDatatypes -> dt
                 in StringDatatypes -> dt
                 in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
@@ -199,7 +173,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
 }
 
 
-class NotConstArgumentException: AstException("not a const argument to a built-in function")        // TODO: ugly, remove throwing exceptions for control flow
+class NotConstArgumentException: AstException("not a const argument to a built-in function")
 
 
 private fun oneDoubleArg(args: List<Expression>, position: Position, program: Program, function: (arg: Double)->Number): NumericLiteralValue {

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -124,7 +124,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         // create the array itself, filled with the fillvalue.
                         val array = Array(size) {fillvalue}.map { NumericLiteralValue.optimalInteger(it, numericLv.position) as Expression}.toTypedArray()
                         val refValue = ArrayLiteralValue(decl.datatype, array, position = numericLv.position)
-                        refValue.addToHeap(program.heap)
+                        refValue.addToHeap()
                         decl.value = refValue
                         refValue.parent=decl
                         optimizationsDone++
@@ -146,7 +146,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                             // create the array itself, filled with the fillvalue.
                             val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) as Expression}.toTypedArray()
                             val refValue = ArrayLiteralValue(DataType.ARRAY_F, array, position = litval.position)
-                            refValue.addToHeap(program.heap)
+                            refValue.addToHeap()
                             decl.value = refValue
                             refValue.parent=decl
                             optimizationsDone++
@@ -610,8 +610,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
         val array = super.visit(arrayLiteral)
         if(array is ArrayLiteralValue) {
-            if(array.heapId==null)
-                array.addToHeap(program.heap)
+            array.addToHeap()
             val vardecl = array.parent as? VarDecl
             return if (vardecl!=null) {
                 fixupArrayDatatype(array, vardecl, program)

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -615,8 +615,6 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
         if(leftVal==null && rightVal==null)
             return expr
 
-        // TODO fix bug in this routine!
-
         // cannot shuffle assiciativity with division!
         if(rightVal!=null) {
             // right value is a constant, see if we can optimize

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -27,10 +27,15 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
 
     private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
     private val callgraph = CallGraph(program)
+    private val vardeclsToRemove = mutableListOf<VarDecl>()
 
     override fun visit(program: Program) {
         removeUnusedCode(callgraph)
         super.visit(program)
+
+        for(decl in vardeclsToRemove) {
+            decl.definingScope().remove(decl)
+        }
     }
 
     private fun removeUnusedCode(callgraph: CallGraph) {
@@ -131,7 +136,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         // removes 'duplicate' assignments that assign the isSameAs target
         val linesToRemove = mutableListOf<Int>()
         var previousAssignmentLine: Int? = null
-        for (i in 0 until statements.size) {
+        for (i in statements.indices) {
             val stmt = statements[i] as? Assignment
             if (stmt != null && stmt.value is NumericLiteralValue) {
                 if (previousAssignmentLine == null) {
@@ -165,24 +170,31 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") ||
                 functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) {
             // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
-            val stringVar = functionCallStatement.arglist.single() as? IdentifierReference
+            val arg = functionCallStatement.arglist.single()
+            val stringVar: IdentifierReference?
+            stringVar = if(arg is AddressOf) {
+                arg.identifier
+            } else {
+                arg as? IdentifierReference
+            }
             if(stringVar!=null) {
-                val heapId = stringVar.heapId(program.namespace)
-                val string = program.heap.get(heapId).str!!
-                if(string.length==1) {
-                    val petscii = Petscii.encodePetscii(string, true)[0]
+                val vardecl = stringVar.targetVarDecl(program.namespace)!!
+                val string = vardecl.value!! as StringLiteralValue
+                val encodedString = Petscii.encodePetscii(string.value, true)
+                if(string.value.length==1) {
                     functionCallStatement.arglist.clear()
-                    functionCallStatement.arglist.add(NumericLiteralValue.optimalInteger(petscii.toInt(), functionCallStatement.position))
+                    functionCallStatement.arglist.add(NumericLiteralValue.optimalInteger(encodedString[0].toInt(), functionCallStatement.position))
                     functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
+                    vardeclsToRemove.add(vardecl)
                     optimizationsDone++
                     return functionCallStatement
-                } else if(string.length==2) {
-                    val petscii = Petscii.encodePetscii(string, true)
+                } else if(string.value.length==2) {
                     val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
                     scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(NumericLiteralValue.optimalInteger(petscii[0].toInt(), functionCallStatement.position)), functionCallStatement.position))
+                            mutableListOf(NumericLiteralValue.optimalInteger(encodedString[0].toInt(), functionCallStatement.position)), functionCallStatement.position))
                     scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
-                            mutableListOf(NumericLiteralValue.optimalInteger(petscii[1].toInt(), functionCallStatement.position)), functionCallStatement.position))
+                            mutableListOf(NumericLiteralValue.optimalInteger(encodedString[1].toInt(), functionCallStatement.position)), functionCallStatement.position))
+                    vardeclsToRemove.add(vardecl)
                     optimizationsDone++
                     return scope
                 }

compiler/src/prog8/vm/RuntimeValue.kt

@@ -1,11 +1,13 @@
 package prog8.vm
 
-import prog8.ast.base.*
+import prog8.ast.base.ByteDatatypes
+import prog8.ast.base.DataType
+import prog8.ast.base.WordDatatypes
 import prog8.ast.expressions.ArrayLiteralValue
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.StringLiteralValue
-import prog8.compiler.HeapValues
 import prog8.compiler.target.c64.Petscii
+import prog8.vm.astvm.VmExecutionException
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.pow
@@ -16,8 +18,14 @@ import kotlin.math.pow
  * this runtime value can be used to *execute* the parsed Ast (or another intermediary form)
  * It contains a value of a variable during run time of the program and provides arithmetic operations on the value.
  */
-open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=null,
-                        val array: Array<Number>?=null, val heapId: Int?=null) {
+
+abstract class RuntimeValueBase(val type: DataType) {
+    abstract fun numericValue(): Number
+    abstract fun integerValue(): Int
+}
+
+
+class RuntimeValueNumeric(type: DataType, num: Number): RuntimeValueBase(type) {
 
     val byteval: Short?
     val wordval: Int?
@@ -25,116 +33,78 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
     val asBoolean: Boolean
 
     companion object {
-        fun fromLv(literalValue: NumericLiteralValue): RuntimeValue {
-            return RuntimeValue(literalValue.type, num = literalValue.number)
+        fun fromLv(literalValue: NumericLiteralValue): RuntimeValueNumeric {
+            return RuntimeValueNumeric(literalValue.type, num = literalValue.number)
         }
-
-        fun fromLv(string: StringLiteralValue, heap: HeapValues): RuntimeValue = fromHeapId(string.heapId!!, heap)
-        fun fromLv(array: ArrayLiteralValue, heap: HeapValues): RuntimeValue = fromHeapId(array.heapId!!, heap)
-
-        fun fromHeapId(heapId: Int, heap: HeapValues): RuntimeValue {
-            val value = heap.get(heapId)
-            return when {
-                value.type in StringDatatypes ->
-                    RuntimeValue(value.type, str = value.str!!, heapId = heapId)
-                value.type in ArrayDatatypes ->
-                    if (value.type == DataType.ARRAY_F) {
-                        RuntimeValue(value.type, array = value.doubleArray!!.toList().toTypedArray(), heapId = heapId)
-                    } else {
-                        val array = value.array!!
-                        val resultArray = mutableListOf<Number>()
-                        for(elt in array.withIndex()){
-                            if(elt.value.integer!=null)
-                                resultArray.add(elt.value.integer!!)
-                            else {
-                                TODO("ADDRESSOF ${elt.value}")
-                            }
-                        }
-                        RuntimeValue(value.type, array = resultArray.toTypedArray(), heapId = heapId)
-                        //RuntimeValue(value.type, array = array.map { it.integer!! }.toTypedArray(), heapId = heapId)
-                    }
-                else -> throw IllegalArgumentException("weird value type on heap $value")
-            }
-        }
-
     }
 
     init {
-        when(type) {
+        when (type) {
             DataType.UBYTE -> {
-                val inum = num!!.toInt()
-                if(inum !in 0 .. 255)
-                    throw IllegalArgumentException("invalid value for ubyte: $inum")
+                val inum = num.toInt()
+                require(inum in 0..255) { "invalid value for ubyte: $inum" }
                 byteval = inum.toShort()
                 wordval = null
                 floatval = null
                 asBoolean = byteval != 0.toShort()
             }
             DataType.BYTE -> {
-                val inum = num!!.toInt()
-                if(inum !in -128 .. 127)
-                    throw IllegalArgumentException("invalid value for byte: $inum")
+                val inum = num.toInt()
+                require(inum in -128..127) { "invalid value for byte: $inum" }
                 byteval = inum.toShort()
                 wordval = null
                 floatval = null
                 asBoolean = byteval != 0.toShort()
             }
             DataType.UWORD -> {
-                val inum = num!!.toInt()
-                if(inum !in 0 .. 65535)
-                    throw IllegalArgumentException("invalid value for uword: $inum")
+                val inum = num.toInt()
+                require(inum in 0..65535) { "invalid value for uword: $inum" }
                 wordval = inum
                 byteval = null
                 floatval = null
                 asBoolean = wordval != 0
             }
             DataType.WORD -> {
-                val inum = num!!.toInt()
-                if(inum !in -32768 .. 32767)
-                    throw IllegalArgumentException("invalid value for word: $inum")
+                val inum = num.toInt()
+                require(inum in -32768..32767) { "invalid value for word: $inum" }
                 wordval = inum
                 byteval = null
                 floatval = null
                 asBoolean = wordval != 0
             }
             DataType.FLOAT -> {
-                floatval = num!!.toDouble()
+                floatval = num.toDouble()
                 byteval = null
                 wordval = null
                 asBoolean = floatval != 0.0
             }
-            else -> {
-                byteval = null
-                wordval = null
-                floatval = null
-                asBoolean = true
-            }
+            else -> throw VmExecutionException("not a numeric value")
         }
     }
 
     override fun toString(): String {
-        return when(type) {
+        return when (type) {
             DataType.UBYTE -> "ub:%02x".format(byteval)
             DataType.BYTE -> {
-                if(byteval!!<0)
+                if (byteval!! < 0)
                     "b:-%02x".format(abs(byteval.toInt()))
                 else
                     "b:%02x".format(byteval)
             }
             DataType.UWORD -> "uw:%04x".format(wordval)
             DataType.WORD -> {
-                if(wordval!!<0)
+                if (wordval!! < 0)
                     "w:-%04x".format(abs(wordval))
                 else
                     "w:%04x".format(wordval)
             }
             DataType.FLOAT -> "f:$floatval"
-            else -> "heap:$heapId"
+            else -> "???"
         }
     }
 
-    fun numericValue(): Number {
-        return when(type) {
+    override fun numericValue(): Number {
+        return when (type) {
             in ByteDatatypes -> byteval!!
             in WordDatatypes -> wordval!!
             DataType.FLOAT -> floatval!!
@@ -142,8 +112,8 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
         }
     }
 
-    fun integerValue(): Int {
-        return when(type) {
+    override fun integerValue(): Int {
+        return when (type) {
             in ByteDatatypes -> byteval!!.toInt()
             in WordDatatypes -> wordval!!
             DataType.FLOAT -> throw ArithmeticException("float to integer loss of precision")
@@ -154,75 +124,69 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
     override fun hashCode(): Int = Objects.hash(byteval, wordval, floatval, type)
 
     override fun equals(other: Any?): Boolean {
-        if(other==null || other !is RuntimeValue)
+        if (other == null || other !is RuntimeValueNumeric)
             return false
-        if(type==other.type)
-            return if (type in IterableDatatypes) heapId==other.heapId else compareTo(other)==0
-        return compareTo(other)==0      // note: datatype doesn't matter
+        return compareTo(other) == 0      // note: datatype doesn't matter
     }
 
-    operator fun compareTo(other: RuntimeValue): Int {
-        return if (type in NumericDatatypes && other.type in NumericDatatypes)
-            numericValue().toDouble().compareTo(other.numericValue().toDouble())
-        else throw ArithmeticException("comparison can only be done between two numeric values")
-    }
+    operator fun compareTo(other: RuntimeValueNumeric): Int = numericValue().toDouble().compareTo(other.numericValue().toDouble())
 
-    private fun arithResult(leftDt: DataType, result: Number, rightDt: DataType, op: String): RuntimeValue {
-        if(leftDt!=rightDt)
+    private fun arithResult(leftDt: DataType, result: Number, rightDt: DataType, op: String): RuntimeValueNumeric {
+        if (leftDt != rightDt)
             throw ArithmeticException("left and right datatypes are not the same")
-        if(result.toDouble() < 0 ) {
-            return when(leftDt) {
+        if (result.toDouble() < 0) {
+            return when (leftDt) {
                 DataType.UBYTE, DataType.UWORD -> {
                     // storing a negative number in an unsigned one is done by storing the 2's complement instead
                     val number = abs(result.toDouble().toInt())
-                    if(leftDt== DataType.UBYTE)
-                        RuntimeValue(DataType.UBYTE, (number xor 255) + 1)
+                    if (leftDt == DataType.UBYTE)
+                        RuntimeValueNumeric(DataType.UBYTE, (number xor 255) + 1)
                     else
-                        RuntimeValue(DataType.UWORD, (number xor 65535) + 1)
+                        RuntimeValueNumeric(DataType.UWORD, (number xor 65535) + 1)
                 }
                 DataType.BYTE -> {
-                    val v=result.toInt() and 255
-                    if(v<128)
-                        RuntimeValue(DataType.BYTE, v)
+                    val v = result.toInt() and 255
+                    if (v < 128)
+                        RuntimeValueNumeric(DataType.BYTE, v)
                     else
-                        RuntimeValue(DataType.BYTE, v-256)
+                        RuntimeValueNumeric(DataType.BYTE, v - 256)
                 }
                 DataType.WORD -> {
-                    val v=result.toInt() and 65535
-                    if(v<32768)
-                        RuntimeValue(DataType.WORD, v)
+                    val v = result.toInt() and 65535
+                    if (v < 32768)
+                        RuntimeValueNumeric(DataType.WORD, v)
                     else
-                        RuntimeValue(DataType.WORD, v-65536)
+                        RuntimeValueNumeric(DataType.WORD, v - 65536)
                 }
-                DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+                DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
                 else -> throw ArithmeticException("$op on non-numeric type")
             }
         }
 
-        return when(leftDt) {
-            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result.toInt() and 255)
+        return when (leftDt) {
+            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, result.toInt() and 255)
             DataType.BYTE -> {
                 val v = result.toInt() and 255
-                if(v<128)
-                    RuntimeValue(DataType.BYTE, v)
+                if (v < 128)
+                    RuntimeValueNumeric(DataType.BYTE, v)
                 else
-                    RuntimeValue(DataType.BYTE, v-256)
+                    RuntimeValueNumeric(DataType.BYTE, v - 256)
             }
-            DataType.UWORD -> RuntimeValue(DataType.UWORD, result.toInt() and 65535)
+            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, result.toInt() and 65535)
             DataType.WORD -> {
                 val v = result.toInt() and 65535
-                if(v<32768)
-                    RuntimeValue(DataType.WORD, v)
+                if (v < 32768)
+                    RuntimeValueNumeric(DataType.WORD, v)
                 else
-                    RuntimeValue(DataType.WORD, v-65536)
+                    RuntimeValueNumeric(DataType.WORD, v - 65536)
             }
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
             else -> throw ArithmeticException("$op on non-numeric type")
         }
     }
 
-    fun add(other: RuntimeValue): RuntimeValue {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+    fun add(other: RuntimeValueNumeric): RuntimeValueNumeric {
+        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
             throw ArithmeticException("floating point loss of precision on type $type")
         val v1 = numericValue()
         val v2 = other.numericValue()
@@ -230,8 +194,8 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
         return arithResult(type, result, other.type, "add")
     }
 
-    fun sub(other: RuntimeValue): RuntimeValue {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+    fun sub(other: RuntimeValueNumeric): RuntimeValueNumeric {
+        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
             throw ArithmeticException("floating point loss of precision on type $type")
         val v1 = numericValue()
         val v2 = other.numericValue()
@@ -239,8 +203,8 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
         return arithResult(type, result, other.type, "sub")
     }
 
-    fun mul(other: RuntimeValue): RuntimeValue {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+    fun mul(other: RuntimeValueNumeric): RuntimeValueNumeric {
+        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
             throw ArithmeticException("floating point loss of precision on type $type")
         val v1 = numericValue()
         val v2 = other.numericValue()
@@ -248,317 +212,318 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
         return arithResult(type, result, other.type, "mul")
     }
 
-    fun div(other: RuntimeValue): RuntimeValue {
-        if(other.type == DataType.FLOAT && (type!= DataType.FLOAT))
+    fun div(other: RuntimeValueNumeric): RuntimeValueNumeric {
+        if (other.type == DataType.FLOAT && (type != DataType.FLOAT))
             throw ArithmeticException("floating point loss of precision on type $type")
         val v1 = numericValue()
         val v2 = other.numericValue()
-        if(v2.toDouble()==0.0) {
+        if (v2.toDouble() == 0.0) {
             when (type) {
-                DataType.UBYTE -> return RuntimeValue(DataType.UBYTE, 255)
-                DataType.BYTE -> return RuntimeValue(DataType.BYTE, 127)
-                DataType.UWORD -> return RuntimeValue(DataType.UWORD, 65535)
-                DataType.WORD -> return RuntimeValue(DataType.WORD, 32767)
-                else -> {}
+                DataType.UBYTE -> return RuntimeValueNumeric(DataType.UBYTE, 255)
+                DataType.BYTE -> return RuntimeValueNumeric(DataType.BYTE, 127)
+                DataType.UWORD -> return RuntimeValueNumeric(DataType.UWORD, 65535)
+                DataType.WORD -> return RuntimeValueNumeric(DataType.WORD, 32767)
+                else -> {
+                }
             }
         }
         val result = v1.toDouble() / v2.toDouble()
         // NOTE: integer division returns integer result!
-        return when(type) {
-            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result)
-            DataType.BYTE -> RuntimeValue(DataType.BYTE, result)
-            DataType.UWORD -> RuntimeValue(DataType.UWORD, result)
-            DataType.WORD -> RuntimeValue(DataType.WORD, result)
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
+        return when (type) {
+            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, result)
+            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, result)
+            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, result)
+            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, result)
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, result)
             else -> throw ArithmeticException("div on non-numeric type")
         }
     }
 
-    fun remainder(other: RuntimeValue): RuntimeValue {
+    fun remainder(other: RuntimeValueNumeric): RuntimeValueNumeric {
         val v1 = numericValue()
         val v2 = other.numericValue()
         val result = v1.toDouble() % v2.toDouble()
         return arithResult(type, result, other.type, "remainder")
     }
 
-    fun pow(other: RuntimeValue): RuntimeValue {
+    fun pow(other: RuntimeValueNumeric): RuntimeValueNumeric {
         val v1 = numericValue()
         val v2 = other.numericValue()
         val result = v1.toDouble().pow(v2.toDouble())
-        return arithResult(type, result, other.type,"pow")
+        return arithResult(type, result, other.type, "pow")
     }
 
-    fun shl(): RuntimeValue {
+    fun shl(): RuntimeValueNumeric {
         val v = integerValue()
         return when (type) {
-            DataType.UBYTE -> RuntimeValue(type, (v shl 1) and 255)
-            DataType.UWORD -> RuntimeValue(type, (v shl 1) and 65535)
+            DataType.UBYTE -> RuntimeValueNumeric(type, (v shl 1) and 255)
+            DataType.UWORD -> RuntimeValueNumeric(type, (v shl 1) and 65535)
             DataType.BYTE -> {
                 val value = v shl 1
-                if(value<128)
-                    RuntimeValue(type, value)
+                if (value < 128)
+                    RuntimeValueNumeric(type, value)
                 else
-                    RuntimeValue(type, value-256)
+                    RuntimeValueNumeric(type, value - 256)
             }
             DataType.WORD -> {
                 val value = v shl 1
-                if(value<32768)
-                    RuntimeValue(type, value)
+                if (value < 32768)
+                    RuntimeValueNumeric(type, value)
                 else
-                    RuntimeValue(type, value-65536)
+                    RuntimeValueNumeric(type, value - 65536)
             }
             else -> throw ArithmeticException("invalid type for shl: $type")
         }
     }
 
-    fun shr(): RuntimeValue {
+    fun shr(): RuntimeValueNumeric {
         val v = integerValue()
-        return when(type){
-            DataType.UBYTE -> RuntimeValue(type, v ushr 1)
-            DataType.BYTE -> RuntimeValue(type, v shr 1)
-            DataType.UWORD -> RuntimeValue(type, v ushr 1)
-            DataType.WORD -> RuntimeValue(type, v shr 1)
+        return when (type) {
+            DataType.UBYTE -> RuntimeValueNumeric(type, v ushr 1)
+            DataType.BYTE -> RuntimeValueNumeric(type, v shr 1)
+            DataType.UWORD -> RuntimeValueNumeric(type, v ushr 1)
+            DataType.WORD -> RuntimeValueNumeric(type, v shr 1)
             else -> throw ArithmeticException("invalid type for shr: $type")
         }
     }
 
-    fun rol(carry: Boolean): Pair<RuntimeValue, Boolean> {
+    fun rol(carry: Boolean): Pair<RuntimeValueNumeric, Boolean> {
         // 9 or 17 bit rotate left (with carry))
-        return when(type) {
+        return when (type) {
             DataType.UBYTE, DataType.BYTE -> {
                 val v = byteval!!.toInt()
                 val newCarry = (v and 0x80) != 0
-                val newval = (v and 0x7f shl 1) or (if(carry) 1 else 0)
-                Pair(RuntimeValue(DataType.UBYTE, newval), newCarry)
+                val newval = (v and 0x7f shl 1) or (if (carry) 1 else 0)
+                Pair(RuntimeValueNumeric(DataType.UBYTE, newval), newCarry)
             }
             DataType.UWORD, DataType.WORD -> {
                 val v = wordval!!
                 val newCarry = (v and 0x8000) != 0
-                val newval = (v and 0x7fff shl 1) or (if(carry) 1 else 0)
-                Pair(RuntimeValue(DataType.UWORD, newval), newCarry)
+                val newval = (v and 0x7fff shl 1) or (if (carry) 1 else 0)
+                Pair(RuntimeValueNumeric(DataType.UWORD, newval), newCarry)
             }
             else -> throw ArithmeticException("rol can only work on byte/word")
         }
     }
 
-    fun ror(carry: Boolean): Pair<RuntimeValue, Boolean> {
+    fun ror(carry: Boolean): Pair<RuntimeValueNumeric, Boolean> {
         // 9 or 17 bit rotate right (with carry)
-        return when(type) {
+        return when (type) {
             DataType.UBYTE, DataType.BYTE -> {
                 val v = byteval!!.toInt()
                 val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if(carry) 0x80 else 0)
-                Pair(RuntimeValue(DataType.UBYTE, newval), newCarry)
+                val newval = (v ushr 1) or (if (carry) 0x80 else 0)
+                Pair(RuntimeValueNumeric(DataType.UBYTE, newval), newCarry)
             }
             DataType.UWORD, DataType.WORD -> {
                 val v = wordval!!
                 val newCarry = v and 1 != 0
-                val newval = (v ushr 1) or (if(carry) 0x8000 else 0)
-                Pair(RuntimeValue(DataType.UWORD, newval), newCarry)
+                val newval = (v ushr 1) or (if (carry) 0x8000 else 0)
+                Pair(RuntimeValueNumeric(DataType.UWORD, newval), newCarry)
             }
             else -> throw ArithmeticException("ror2 can only work on byte/word")
         }
     }
 
-    fun rol2(): RuntimeValue {
+    fun rol2(): RuntimeValueNumeric {
         // 8 or 16 bit rotate left
-        return when(type) {
+        return when (type) {
             DataType.UBYTE, DataType.BYTE -> {
                 val v = byteval!!.toInt()
                 val carry = (v and 0x80) ushr 7
                 val newval = (v and 0x7f shl 1) or carry
-                RuntimeValue(DataType.UBYTE, newval)
+                RuntimeValueNumeric(DataType.UBYTE, newval)
             }
             DataType.UWORD, DataType.WORD -> {
                 val v = wordval!!
                 val carry = (v and 0x8000) ushr 15
                 val newval = (v and 0x7fff shl 1) or carry
-                RuntimeValue(DataType.UWORD, newval)
+                RuntimeValueNumeric(DataType.UWORD, newval)
             }
             else -> throw ArithmeticException("rol2 can only work on byte/word")
         }
     }
 
-    fun ror2(): RuntimeValue {
+    fun ror2(): RuntimeValueNumeric {
         // 8 or 16 bit rotate right
-        return when(type) {
+        return when (type) {
             DataType.UBYTE, DataType.BYTE -> {
                 val v = byteval!!.toInt()
                 val carry = v and 1 shl 7
                 val newval = (v ushr 1) or carry
-                RuntimeValue(DataType.UBYTE, newval)
+                RuntimeValueNumeric(DataType.UBYTE, newval)
             }
             DataType.UWORD, DataType.WORD -> {
                 val v = wordval!!
                 val carry = v and 1 shl 15
                 val newval = (v ushr 1) or carry
-                RuntimeValue(DataType.UWORD, newval)
+                RuntimeValueNumeric(DataType.UWORD, newval)
             }
             else -> throw ArithmeticException("ror2 can only work on byte/word")
         }
     }
 
-    fun neg(): RuntimeValue {
-        return when(type) {
-            DataType.BYTE -> RuntimeValue(DataType.BYTE, -(byteval!!))
-            DataType.WORD -> RuntimeValue(DataType.WORD, -(wordval!!))
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, -(floatval)!!)
+    fun neg(): RuntimeValueNumeric {
+        return when (type) {
+            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, -(byteval!!))
+            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, -(wordval!!))
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, -(floatval)!!)
             else -> throw ArithmeticException("neg can only work on byte/word/float")
         }
     }
 
-    fun abs(): RuntimeValue {
-        return when(type) {
-            DataType.BYTE -> RuntimeValue(DataType.BYTE, abs(byteval!!.toInt()))
-            DataType.WORD -> RuntimeValue(DataType.WORD, abs(wordval!!))
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(floatval!!))
+    fun abs(): RuntimeValueNumeric {
+        return when (type) {
+            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, abs(byteval!!.toInt()))
+            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, abs(wordval!!))
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, abs(floatval!!))
             else -> throw ArithmeticException("abs can only work on byte/word/float")
         }
     }
 
-    fun bitand(other: RuntimeValue): RuntimeValue {
+    fun bitand(other: RuntimeValueNumeric): RuntimeValueNumeric {
         val v1 = integerValue()
         val v2 = other.integerValue()
         val result = v1 and v2
-        return RuntimeValue(type, result)
+        return RuntimeValueNumeric(type, result)
     }
 
-    fun bitor(other: RuntimeValue): RuntimeValue {
+    fun bitor(other: RuntimeValueNumeric): RuntimeValueNumeric {
         val v1 = integerValue()
         val v2 = other.integerValue()
         val result = v1 or v2
-        return RuntimeValue(type, result)
+        return RuntimeValueNumeric(type, result)
     }
 
-    fun bitxor(other: RuntimeValue): RuntimeValue {
+    fun bitxor(other: RuntimeValueNumeric): RuntimeValueNumeric {
         val v1 = integerValue()
         val v2 = other.integerValue()
         val result = v1 xor v2
-        return RuntimeValue(type, result)
+        return RuntimeValueNumeric(type, result)
     }
 
-    fun and(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean && other.asBoolean) 1 else 0)
-    fun or(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean || other.asBoolean) 1 else 0)
-    fun xor(other: RuntimeValue) = RuntimeValue(DataType.UBYTE, if (this.asBoolean xor other.asBoolean) 1 else 0)
-    fun not() = RuntimeValue(DataType.UBYTE, if (this.asBoolean) 0 else 1)
+    fun and(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean && other.asBoolean) 1 else 0)
+    fun or(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean || other.asBoolean) 1 else 0)
+    fun xor(other: RuntimeValueNumeric) = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean xor other.asBoolean) 1 else 0)
+    fun not() = RuntimeValueNumeric(DataType.UBYTE, if (this.asBoolean) 0 else 1)
 
-    fun inv(): RuntimeValue {
-        return when(type) {
-            DataType.UBYTE -> RuntimeValue(type, byteval!!.toInt().inv() and 255)
-            DataType.UWORD -> RuntimeValue(type, wordval!!.inv() and 65535)
-            DataType.BYTE -> RuntimeValue(type, byteval!!.toInt().inv())
-            DataType.WORD -> RuntimeValue(type, wordval!!.inv())
+    fun inv(): RuntimeValueNumeric {
+        return when (type) {
+            DataType.UBYTE -> RuntimeValueNumeric(type, byteval!!.toInt().inv() and 255)
+            DataType.UWORD -> RuntimeValueNumeric(type, wordval!!.inv() and 65535)
+            DataType.BYTE -> RuntimeValueNumeric(type, byteval!!.toInt().inv())
+            DataType.WORD -> RuntimeValueNumeric(type, wordval!!.inv())
             else -> throw ArithmeticException("inv can only work on byte/word")
         }
     }
 
-    fun inc(): RuntimeValue {
-        return when(type) {
-            DataType.UBYTE -> RuntimeValue(type, (byteval!! + 1) and 255)
-            DataType.UWORD -> RuntimeValue(type, (wordval!! + 1) and 65535)
+    fun inc(): RuntimeValueNumeric {
+        return when (type) {
+            DataType.UBYTE -> RuntimeValueNumeric(type, (byteval!! + 1) and 255)
+            DataType.UWORD -> RuntimeValueNumeric(type, (wordval!! + 1) and 65535)
             DataType.BYTE -> {
                 val newval = byteval!! + 1
-                if(newval == 128)
-                    RuntimeValue(type, -128)
+                if (newval == 128)
+                    RuntimeValueNumeric(type, -128)
                 else
-                    RuntimeValue(type, newval)
+                    RuntimeValueNumeric(type, newval)
             }
             DataType.WORD -> {
                 val newval = wordval!! + 1
-                if(newval == 32768)
-                    RuntimeValue(type, -32768)
+                if (newval == 32768)
+                    RuntimeValueNumeric(type, -32768)
                 else
-                    RuntimeValue(type, newval)
+                    RuntimeValueNumeric(type, newval)
             }
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! + 1)
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, floatval!! + 1)
             else -> throw ArithmeticException("inc can only work on numeric types")
         }
     }
 
-    fun dec(): RuntimeValue {
-        return when(type) {
-            DataType.UBYTE -> RuntimeValue(type, (byteval!! - 1) and 255)
-            DataType.UWORD -> RuntimeValue(type, (wordval!! - 1) and 65535)
+    fun dec(): RuntimeValueNumeric {
+        return when (type) {
+            DataType.UBYTE -> RuntimeValueNumeric(type, (byteval!! - 1) and 255)
+            DataType.UWORD -> RuntimeValueNumeric(type, (wordval!! - 1) and 65535)
             DataType.BYTE -> {
                 val newval = byteval!! - 1
-                if(newval == -129)
-                    RuntimeValue(type, 127)
+                if (newval == -129)
+                    RuntimeValueNumeric(type, 127)
                 else
-                    RuntimeValue(type, newval)
+                    RuntimeValueNumeric(type, newval)
             }
             DataType.WORD -> {
                 val newval = wordval!! - 1
-                if(newval == -32769)
-                    RuntimeValue(type, 32767)
+                if (newval == -32769)
+                    RuntimeValueNumeric(type, 32767)
                 else
-                    RuntimeValue(type, newval)
+                    RuntimeValueNumeric(type, newval)
             }
-            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! - 1)
+            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, floatval!! - 1)
             else -> throw ArithmeticException("dec can only work on numeric types")
         }
     }
 
-    fun msb(): RuntimeValue {
-        return when(type) {
-            in ByteDatatypes -> RuntimeValue(DataType.UBYTE, 0)
-            in WordDatatypes -> RuntimeValue(DataType.UBYTE, wordval!! ushr 8 and 255)
+    fun msb(): RuntimeValueNumeric {
+        return when (type) {
+            in ByteDatatypes -> RuntimeValueNumeric(DataType.UBYTE, 0)
+            in WordDatatypes -> RuntimeValueNumeric(DataType.UBYTE, wordval!! ushr 8 and 255)
             else -> throw ArithmeticException("msb can only work on (u)byte/(u)word")
         }
     }
 
-    fun cast(targetType: DataType): RuntimeValue {
+    fun cast(targetType: DataType): RuntimeValueNumeric {
         return when (type) {
             DataType.UBYTE -> {
                 when (targetType) {
                     DataType.UBYTE -> this
                     DataType.BYTE -> {
-                        val nval=byteval!!.toInt()
-                        if(nval<128)
-                            RuntimeValue(DataType.BYTE, nval)
+                        val nval = byteval!!.toInt()
+                        if (nval < 128)
+                            RuntimeValueNumeric(DataType.BYTE, nval)
                         else
-                            RuntimeValue(DataType.BYTE, nval-256)
+                            RuntimeValueNumeric(DataType.BYTE, nval - 256)
                     }
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, numericValue())
+                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, numericValue())
                     DataType.WORD -> {
                         val nval = numericValue().toInt()
-                        if(nval<32768)
-                            RuntimeValue(DataType.WORD, nval)
+                        if (nval < 32768)
+                            RuntimeValueNumeric(DataType.WORD, nval)
                         else
-                            RuntimeValue(DataType.WORD, nval-65536)
+                            RuntimeValueNumeric(DataType.WORD, nval - 65536)
                     }
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
             }
             DataType.BYTE -> {
                 when (targetType) {
                     DataType.BYTE -> this
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue() and 65535)
-                    DataType.WORD -> RuntimeValue(DataType.WORD, integerValue())
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 255)
+                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, integerValue() and 65535)
+                    DataType.WORD -> RuntimeValueNumeric(DataType.WORD, integerValue())
+                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
             }
             DataType.UWORD -> {
                 when (targetType) {
                     DataType.BYTE -> {
-                        val v=integerValue()
-                        if(v<128)
-                            RuntimeValue(DataType.BYTE, v)
+                        val v = integerValue()
+                        if (v < 128)
+                            RuntimeValueNumeric(DataType.BYTE, v)
                         else
-                            RuntimeValue(DataType.BYTE, v-256)
+                            RuntimeValueNumeric(DataType.BYTE, v - 256)
                     }
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
+                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 255)
                     DataType.UWORD -> this
                     DataType.WORD -> {
-                        val v=integerValue()
-                        if(v<32768)
-                            RuntimeValue(DataType.WORD, v)
+                        val v = integerValue()
+                        if (v < 32768)
+                            RuntimeValueNumeric(DataType.WORD, v)
                         else
-                            RuntimeValue(DataType.WORD, v-65536)
+                            RuntimeValueNumeric(DataType.WORD, v - 65536)
                     }
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
             }
@@ -566,33 +531,33 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
                 when (targetType) {
                     DataType.BYTE -> {
                         val v = integerValue() and 255
-                        if(v<128)
-                            RuntimeValue(DataType.BYTE, v)
+                        if (v < 128)
+                            RuntimeValueNumeric(DataType.BYTE, v)
                         else
-                            RuntimeValue(DataType.BYTE, v-256)
+                            RuntimeValueNumeric(DataType.BYTE, v - 256)
                     }
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 65535)
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue())
+                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, integerValue() and 65535)
+                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, integerValue())
                     DataType.WORD -> this
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
+                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
             }
             DataType.FLOAT -> {
                 when (targetType) {
                     DataType.BYTE -> {
-                        val integer=numericValue().toInt()
-                        if(integer in -128..127)
-                            RuntimeValue(DataType.BYTE, integer)
+                        val integer = numericValue().toInt()
+                        if (integer in -128..127)
+                            RuntimeValueNumeric(DataType.BYTE, integer)
                         else
                             throw ArithmeticException("overflow when casting float to byte: $this")
                     }
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, numericValue().toInt())
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, numericValue().toInt())
+                    DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, numericValue().toInt())
+                    DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, numericValue().toInt())
                     DataType.WORD -> {
-                        val integer=numericValue().toInt()
-                        if(integer in -32768..32767)
-                            RuntimeValue(DataType.WORD, integer)
+                        val integer = numericValue().toInt()
+                        if (integer in -32768..32767)
+                            RuntimeValueNumeric(DataType.WORD, integer)
                         else
                             throw ArithmeticException("overflow when casting float to word: $this")
                     }
@@ -603,22 +568,97 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             else -> throw ArithmeticException("invalid type cast from $type to $targetType")
         }
     }
+}
 
-    open fun iterator(): Iterator<Number> {
-        return when (type) {
-            in StringDatatypes -> {
-                Petscii.encodePetscii(str!!, true).iterator()
-            }
-            in ArrayDatatypes -> {
-                array!!.iterator()
-            }
-            else -> throw IllegalArgumentException("cannot iterate over $this")
+
+class RuntimeValueString(type: DataType, val str: String, val heapId: Int?): RuntimeValueBase(type) {
+    companion object {
+        fun fromLv(string: StringLiteralValue): RuntimeValueString {
+            return RuntimeValueString(string.type, string.value, string.heapId!!)
         }
     }
+
+    override fun toString(): String {
+        return when (type) {
+            DataType.STR -> "str:$str"
+            DataType.STR_S -> "str_s:$str"
+            else -> "???"
+        }
+    }
+
+    override fun hashCode(): Int = Objects.hash(type, str)
+
+    override fun equals(other: Any?): Boolean {
+        if (other == null || other !is RuntimeValueString)
+            return false
+        return type == other.type && str == other.str
+    }
+
+    fun iterator(): Iterator<Number> = Petscii.encodePetscii(str, true).iterator()
+
+    override fun numericValue(): Number {
+        throw VmExecutionException("string is not a number")
+    }
+
+    override fun integerValue(): Int {
+        throw VmExecutionException("string is not a number")
+    }
 }
 
 
-class RuntimeValueRange(type: DataType, val range: IntProgression): RuntimeValue(type, array=range.toList().toTypedArray()) {
+open class RuntimeValueArray(type: DataType, val array: Array<Number>, val heapId: Int?): RuntimeValueBase(type) {
+
+    companion object {
+        fun fromLv(array: ArrayLiteralValue): RuntimeValueArray {
+            return if (array.type == DataType.ARRAY_F) {
+                val doubleArray = array.value.map { (it as NumericLiteralValue).number }.toTypedArray()
+                RuntimeValueArray(array.type, doubleArray, array.heapId!!)
+            } else {
+                val resultArray = mutableListOf<Number>()
+                for (elt in array.value.withIndex()) {
+                    if (elt.value is NumericLiteralValue)
+                        resultArray.add((elt.value as NumericLiteralValue).number.toInt())
+                    else {
+                        TODO("ADDRESSOF ${elt.value}")
+                    }
+                }
+                RuntimeValueArray(array.type, resultArray.toTypedArray(), array.heapId!!)
+            }
+        }
+    }
+
+    override fun toString(): String {
+        return when (type) {
+            DataType.ARRAY_UB -> "array_ub:..."
+            DataType.ARRAY_B -> "array_b:..."
+            DataType.ARRAY_UW -> "array_uw:..."
+            DataType.ARRAY_W -> "array_w:..."
+            DataType.ARRAY_F -> "array_f:..."
+            else -> "???"
+        }
+    }
+
+    override fun hashCode(): Int = Objects.hash(type, array)
+
+    override fun equals(other: Any?): Boolean {
+        if (other == null || other !is RuntimeValueArray)
+            return false
+        return type == other.type && array.contentEquals(other.array)
+    }
+
+    open fun iterator(): Iterator<Number> = array.iterator()
+
+    override fun numericValue(): Number {
+        throw VmExecutionException("array is not a number")
+    }
+
+    override fun integerValue(): Int {
+        throw VmExecutionException("array is not a number")
+    }
+}
+
+
+class RuntimeValueRange(type: DataType, val range: IntProgression): RuntimeValueArray(type, range.toList().toTypedArray(), null) {
     override fun iterator(): Iterator<Number> {
         return range.iterator()
     }

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

@@ -7,11 +7,9 @@ import prog8.ast.expressions.Expression
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.*
-import prog8.compiler.IntegerOrAddressOf
 import prog8.compiler.target.c64.MachineDefinition
 import prog8.compiler.target.c64.Petscii
-import prog8.vm.RuntimeValue
-import prog8.vm.RuntimeValueRange
+import prog8.vm.*
 import java.awt.EventQueue
 import java.io.CharConversionException
 import java.util.*
@@ -72,10 +70,14 @@ class StatusFlags {
 
 
 class RuntimeVariables {
-    fun define(scope: INameScope, name: String, initialValue: RuntimeValue) {
+    fun define(scope: INameScope, name: String, initialValue: RuntimeValueBase) {
         val where = vars.getValue(scope)
         where[name] = initialValue
         vars[scope] = where
+        if(initialValue is RuntimeValueString)
+            byHeapId[initialValue.heapId!!] = initialValue
+        else if(initialValue is RuntimeValueArray)
+            byHeapId[initialValue.heapId!!] = initialValue
     }
 
     fun defineMemory(scope: INameScope, name: String, address: Int) {
@@ -84,7 +86,7 @@ class RuntimeVariables {
         memvars[scope] = where
     }
 
-    fun set(scope: INameScope, name: String, value: RuntimeValue) {
+    fun set(scope: INameScope, name: String, value: RuntimeValueBase) {
         val where = vars.getValue(scope)
         val existing = where[name]
         if(existing==null) {
@@ -96,9 +98,15 @@ class RuntimeVariables {
             throw VmExecutionException("new value is of different datatype ${value.type} expected ${existing.type} for $name")
         where[name] = value
         vars[scope] = where
+        if(value is RuntimeValueString)
+            byHeapId[value.heapId!!] = value
+        else if(value is RuntimeValueArray)
+            byHeapId[value.heapId!!] = value
     }
 
-    fun get(scope: INameScope, name: String): RuntimeValue {
+    fun getByHeapId(heapId: Int): RuntimeValueBase = byHeapId.getValue(heapId)
+
+    fun get(scope: INameScope, name: String): RuntimeValueBase {
         val where = vars.getValue(scope)
         return where[name] ?: throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
     }
@@ -108,8 +116,6 @@ class RuntimeVariables {
         return where[name] ?: throw NoSuchElementException("no such runtime memory-variable: ${scope.name}.$name")
     }
 
-    fun swap(a1: VarDecl, a2: VarDecl) = swap(a1.definingScope(), a1.name, a2.definingScope(), a2.name)
-
     fun swap(scope1: INameScope, name1: String, scope2: INameScope, name2: String) {
         val v1 = get(scope1, name1)
         val v2 = get(scope2, name2)
@@ -117,8 +123,9 @@ class RuntimeVariables {
         set(scope2, name2, v1)
     }
 
-    private val vars = mutableMapOf<INameScope, MutableMap<String, RuntimeValue>>().withDefault { mutableMapOf() }
+    private val vars = mutableMapOf<INameScope, MutableMap<String, RuntimeValueBase>>().withDefault { mutableMapOf() }
     private val memvars = mutableMapOf<INameScope, MutableMap<String, Int>>().withDefault { mutableMapOf() }
+    private val byHeapId = mutableMapOf<Int, RuntimeValueBase>()
 }
 
 
@@ -134,9 +141,9 @@ class AstVm(val program: Program) {
 
     private val rnd = Random(0)
     private val statusFlagsSave = Stack<StatusFlags>()
-    private val registerXsave = Stack<RuntimeValue>()
-    private val registerYsave = Stack<RuntimeValue>()
-    private val registerAsave = Stack<RuntimeValue>()
+    private val registerXsave = Stack<RuntimeValueNumeric>()
+    private val registerYsave = Stack<RuntimeValueNumeric>()
+    private val registerAsave = Stack<RuntimeValueNumeric>()
 
 
     init {
@@ -182,7 +189,7 @@ class AstVm(val program: Program) {
 
     fun run() {
         try {
-            val init = VariablesCreator(runtimeVariables, program.heap)
+            val init = VariablesCreator(runtimeVariables)
             init.visit(program)
 
             // initialize all global variables
@@ -263,11 +270,11 @@ class AstVm(val program: Program) {
 
     class LoopControlBreak : Exception()
     class LoopControlContinue : Exception()
-    class LoopControlReturn(val returnvalue: RuntimeValue?) : Exception()
+    class LoopControlReturn(val returnvalue: RuntimeValueNumeric?) : Exception()
     class LoopControlJump(val identifier: IdentifierReference?, val address: Int?, val generatedLabel: String?) : Exception()
 
 
-    internal fun executeSubroutine(sub: Subroutine, arguments: List<RuntimeValue>, startAtLabel: Label?=null): RuntimeValue? {
+    internal fun executeSubroutine(sub: Subroutine, arguments: List<RuntimeValueNumeric>, startAtLabel: Label?=null): RuntimeValueNumeric? {
         if(sub.isAsmSubroutine) {
             return performSyscall(sub, arguments)
         }
@@ -335,7 +342,7 @@ class AstVm(val program: Program) {
                 val target = stmt.target.targetStatement(program.namespace)
                 when (target) {
                     is Subroutine -> {
-                        val args = evaluate(stmt.arglist)
+                        val args = evaluate(stmt.arglist).map { it as RuntimeValueNumeric }
                         if (target.isAsmSubroutine) {
                             performSyscall(target, args)
                         } else {
@@ -348,7 +355,7 @@ class AstVm(val program: Program) {
                             // swap cannot be implemented as a function, so inline it here
                             executeSwap(stmt)
                         } else {
-                            val args = evaluate(stmt.arglist)
+                            val args = evaluate(stmt.arglist).map { it as RuntimeValueNumeric }
                             performBuiltinFunction(target.name, args, statusflags)
                         }
                     }
@@ -362,7 +369,7 @@ class AstVm(val program: Program) {
                         if(stmt.value==null)
                             null
                         else
-                            evaluate(stmt.value!!, evalCtx)
+                            evaluate(stmt.value!!, evalCtx) as RuntimeValueNumeric
                 throw LoopControlReturn(value)
             }
             is Continue -> throw LoopControlContinue()
@@ -380,10 +387,10 @@ class AstVm(val program: Program) {
                         val identScope = ident.definingScope()
                         when(ident.type){
                             VarDeclType.VAR -> {
-                                var value = runtimeVariables.get(identScope, ident.name)
+                                var value = runtimeVariables.get(identScope, ident.name) as RuntimeValueNumeric
                                 value = when {
-                                    stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
-                                    stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                                    stmt.operator == "++" -> value.add(RuntimeValueNumeric(value.type, 1))
+                                    stmt.operator == "--" -> value.sub(RuntimeValueNumeric(value.type, 1))
                                     else -> throw VmExecutionException("strange postincdec operator $stmt")
                                 }
                                 runtimeVariables.set(identScope, ident.name, value)
@@ -401,7 +408,7 @@ class AstVm(val program: Program) {
                         }
                     }
                     stmt.target.memoryAddress != null -> {
-                        val addr = evaluate(stmt.target.memoryAddress!!.addressExpression, evalCtx).integerValue()
+                        val addr = (evaluate(stmt.target.memoryAddress!!.addressExpression, evalCtx) as RuntimeValueNumeric).integerValue()
                         val newval = when {
                             stmt.operator == "++" -> mem.getUByte(addr)+1 and 255
                             stmt.operator == "--" -> mem.getUByte(addr)-1 and 255
@@ -411,12 +418,12 @@ class AstVm(val program: Program) {
                     }
                     stmt.target.arrayindexed != null -> {
                         val arrayvar = stmt.target.arrayindexed!!.identifier.targetVarDecl(program.namespace)!!
-                        val arrayvalue = runtimeVariables.get(arrayvar.definingScope(), arrayvar.name)
-                        val index = evaluate(stmt.target.arrayindexed!!.arrayspec.index, evalCtx).integerValue()
+                        val arrayvalue = runtimeVariables.get(arrayvar.definingScope(), arrayvar.name) as RuntimeValueArray
+                        val index = (evaluate(stmt.target.arrayindexed!!.arrayspec.index, evalCtx) as RuntimeValueNumeric).integerValue()
                         val elementType = stmt.target.arrayindexed!!.inferType(program)
                         if(!elementType.isKnown)
                             throw VmExecutionException("unknown/void elt type")
-                        var value = RuntimeValue(elementType.typeOrElse(DataType.BYTE), arrayvalue.array!![index].toInt())
+                        var value = RuntimeValueNumeric(elementType.typeOrElse(DataType.BYTE), arrayvalue.array[index].toInt())
                         value = when {
                             stmt.operator == "++" -> value.inc()
                             stmt.operator == "--" -> value.dec()
@@ -425,10 +432,10 @@ class AstVm(val program: Program) {
                         arrayvalue.array[index] = value.numericValue()
                     }
                     stmt.target.register != null -> {
-                        var value = runtimeVariables.get(program.namespace, stmt.target.register!!.name)
+                        var value = runtimeVariables.get(program.namespace, stmt.target.register!!.name) as RuntimeValueNumeric
                         value = when {
-                            stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
-                            stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                            stmt.operator == "++" -> value.add(RuntimeValueNumeric(value.type, 1))
+                            stmt.operator == "--" -> value.sub(RuntimeValueNumeric(value.type, 1))
                             else -> throw VmExecutionException("strange postincdec operator $stmt")
                         }
                         runtimeVariables.set(program.namespace, stmt.target.register!!.name, value)
@@ -439,7 +446,7 @@ class AstVm(val program: Program) {
             is Jump -> throw LoopControlJump(stmt.identifier, stmt.address, stmt.generatedLabel)
             is InlineAssembly -> {
                 if (sub is Subroutine) {
-                    val args = sub.parameters.map { runtimeVariables.get(sub, it.name) }
+                    val args = sub.parameters.map { runtimeVariables.get(sub, it.name) as RuntimeValueNumeric }
                     performSyscall(sub, args)
                     throw LoopControlReturn(null)
                 }
@@ -447,7 +454,7 @@ class AstVm(val program: Program) {
             }
             is AnonymousScope -> executeAnonymousScope(stmt)
             is IfStatement -> {
-                val condition = evaluate(stmt.condition, evalCtx)
+                val condition = evaluate(stmt.condition, evalCtx) as RuntimeValueNumeric
                 if (condition.asBoolean)
                     executeAnonymousScope(stmt.truepart)
                 else
@@ -478,7 +485,13 @@ class AstVm(val program: Program) {
                     loopvarDt = dt.typeOrElse(DataType.UBYTE)
                     loopvar = stmt.loopVar!!
                 }
-                val iterator = iterable.iterator()
+                val iterator =
+                        when (iterable) {
+                            is RuntimeValueRange -> iterable.iterator()
+                            is RuntimeValueArray -> iterable.iterator()
+                            is RuntimeValueString -> iterable.iterator()
+                            else -> throw VmExecutionException("not iterable")
+                        }
                 for (loopvalue in iterator) {
                     try {
                         oneForCycle(stmt, loopvarDt, loopvalue, loopvar)
@@ -490,11 +503,11 @@ class AstVm(val program: Program) {
                 }
             }
             is WhileLoop -> {
-                var condition = evaluate(stmt.condition, evalCtx)
+                var condition = evaluate(stmt.condition, evalCtx) as RuntimeValueNumeric
                 while (condition.asBoolean) {
                     try {
                         executeAnonymousScope(stmt.body)
-                        condition = evaluate(stmt.condition, evalCtx)
+                        condition = evaluate(stmt.condition, evalCtx) as RuntimeValueNumeric
                     } catch (b: LoopControlBreak) {
                         break
                     } catch (c: LoopControlContinue) {
@@ -504,7 +517,7 @@ class AstVm(val program: Program) {
             }
             is RepeatLoop -> {
                 do {
-                    val condition = evaluate(stmt.untilCondition, evalCtx)
+                    val condition = evaluate(stmt.untilCondition, evalCtx) as RuntimeValueNumeric
                     try {
                         executeAnonymousScope(stmt.body)
                     } catch (b: LoopControlBreak) {
@@ -515,7 +528,7 @@ class AstVm(val program: Program) {
                 } while (!condition.asBoolean)
             }
             is WhenStatement -> {
-                val condition=evaluate(stmt.condition, evalCtx)
+                val condition=evaluate(stmt.condition, evalCtx) as RuntimeValueNumeric
                 for(choice in stmt.choices) {
                     if(choice.values==null) {
                         // the 'else' choice
@@ -523,7 +536,7 @@ class AstVm(val program: Program) {
                         break
                     } else {
                         val value = choice.values!!.single().constValue(evalCtx.program) ?: throw VmExecutionException("can only use const values in when choices ${choice.position}")
-                        val rtval = RuntimeValue.fromLv(value)
+                        val rtval = RuntimeValueNumeric.fromLv(value)
                         if(condition==rtval) {
                             executeAnonymousScope(choice.statements)
                             break
@@ -548,7 +561,7 @@ class AstVm(val program: Program) {
         performAssignment(target2, value1, swap, evalCtx)
     }
 
-    fun performAssignment(target: AssignTarget, value: RuntimeValue, contextStmt: Statement, evalCtx: EvalContext) {
+    fun performAssignment(target: AssignTarget, value: RuntimeValueBase, contextStmt: Statement, evalCtx: EvalContext) {
         val targetIdent = target.identifier
         val targetArrayIndexed = target.arrayindexed
         when {
@@ -558,27 +571,27 @@ class AstVm(val program: Program) {
                 if (decl.type == VarDeclType.MEMORY) {
                     val address = runtimeVariables.getMemoryAddress(decl.definingScope(), decl.name)
                     when (decl.datatype) {
-                        DataType.UBYTE -> mem.setUByte(address, value.byteval!!)
-                        DataType.BYTE -> mem.setSByte(address, value.byteval!!)
-                        DataType.UWORD -> mem.setUWord(address, value.wordval!!)
-                        DataType.WORD -> mem.setSWord(address, value.wordval!!)
-                        DataType.FLOAT -> mem.setFloat(address, value.floatval!!)
-                        DataType.STR -> mem.setString(address, value.str!!)
-                        DataType.STR_S -> mem.setScreencodeString(address, value.str!!)
+                        DataType.UBYTE -> mem.setUByte(address, (value as RuntimeValueNumeric).byteval!!)
+                        DataType.BYTE -> mem.setSByte(address, (value as RuntimeValueNumeric).byteval!!)
+                        DataType.UWORD -> mem.setUWord(address, (value as RuntimeValueNumeric).wordval!!)
+                        DataType.WORD -> mem.setSWord(address, (value as RuntimeValueNumeric).wordval!!)
+                        DataType.FLOAT -> mem.setFloat(address, (value as RuntimeValueNumeric).floatval!!)
+                        DataType.STR -> mem.setString(address, (value as RuntimeValueString).str)
+                        DataType.STR_S -> mem.setScreencodeString(address, (value as RuntimeValueString).str)
                         else -> throw VmExecutionException("weird memaddress type $decl")
                     }
                 } else
                     runtimeVariables.set(decl.definingScope(), decl.name, value)
             }
             target.memoryAddress != null -> {
-                val address = evaluate(target.memoryAddress.addressExpression, evalCtx).wordval!!
-                evalCtx.mem.setUByte(address, value.byteval!!)
+                val address = (evaluate(target.memoryAddress.addressExpression, evalCtx) as RuntimeValueNumeric).wordval!!
+                evalCtx.mem.setUByte(address, (value as RuntimeValueNumeric).byteval!!)
             }
             targetArrayIndexed != null -> {
                 val vardecl = targetArrayIndexed.identifier.targetVarDecl(program.namespace)!!
                 if(vardecl.type==VarDeclType.VAR) {
                     val array = evaluate(targetArrayIndexed.identifier, evalCtx)
-                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx)
+                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx) as RuntimeValueNumeric
                     when (array.type) {
                         DataType.ARRAY_UB -> {
                             if (value.type != DataType.UBYTE)
@@ -607,21 +620,21 @@ class AstVm(val program: Program) {
                         else -> throw VmExecutionException("strange array type ${array.type}")
                     }
                     if (array.type in ArrayDatatypes)
-                        array.array!![index.integerValue()] = value.numericValue()
+                        (array as RuntimeValueArray).array[index.integerValue()] = value.numericValue()
                     else if (array.type in StringDatatypes) {
                         val indexInt = index.integerValue()
                         val newchr = Petscii.decodePetscii(listOf(value.numericValue().toShort()), true)
-                        val newstr = array.str!!.replaceRange(indexInt, indexInt + 1, newchr)
+                        val newstr = (array as RuntimeValueString).str.replaceRange(indexInt, indexInt + 1, newchr)
                         val ident = contextStmt.definingScope().lookup(targetArrayIndexed.identifier.nameInSource, contextStmt) as? VarDecl
                                 ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
                         val identScope = ident.definingScope()
-                        program.heap.update(array.heapId!!, newstr)
-                        runtimeVariables.set(identScope, ident.name, RuntimeValue(array.type, str = newstr, heapId = array.heapId))
+                        runtimeVariables.set(identScope, ident.name, RuntimeValueString(array.type, newstr, array.heapId))
                     }
                 }
                 else {
+                    value as RuntimeValueNumeric
                     val address = (vardecl.value as NumericLiteralValue).number.toInt()
-                    val index = evaluate(targetArrayIndexed.arrayspec.index, evalCtx).integerValue()
+                    val index = (evaluate(targetArrayIndexed.arrayspec.index, evalCtx) as RuntimeValueNumeric).integerValue()
                     val elementType = targetArrayIndexed.inferType(program)
                     if(!elementType.isKnown)
                         throw VmExecutionException("unknown/void array elt type $targetArrayIndexed")
@@ -645,22 +658,22 @@ class AstVm(val program: Program) {
     private fun oneForCycle(stmt: ForLoop, loopvarDt: DataType, loopValue: Number, loopVar: IdentifierReference) {
         // assign the new loop value to the loopvar, and run the code
         performAssignment(AssignTarget(null, loopVar, null, null, loopVar.position),
-                RuntimeValue(loopvarDt, loopValue), stmt.body.statements.first(), evalCtx)
+                RuntimeValueNumeric(loopvarDt, loopValue), stmt.body.statements.first(), evalCtx)
         executeAnonymousScope(stmt.body)
     }
 
     private fun evaluate(args: List<Expression>) = args.map { evaluate(it, evalCtx) }
 
-    private fun performSyscall(sub: Subroutine, args: List<RuntimeValue>): RuntimeValue? {
-        var result: RuntimeValue? = null
+    private fun performSyscall(sub: Subroutine, args: List<RuntimeValueNumeric>): RuntimeValueNumeric? {
+        var result: RuntimeValueNumeric? = null
         when (sub.scopedname) {
             "c64scr.print" -> {
                 // if the argument is an UWORD, consider it to be the "address" of the string (=heapId)
                 if (args[0].wordval != null) {
-                    val str = program.heap.get(args[0].wordval!!).str!!
-                    dialog.canvas.printText(str, true)
+                    val encodedStr = getEncodedStringFromRuntimeVars(args[0].wordval!!)
+                    dialog.canvas.printText(encodedStr)
                 } else
-                    dialog.canvas.printText(args[0].str!!, true)
+                    throw VmExecutionException("print non-heap string")
             }
             "c64scr.print_ub" -> {
                 dialog.canvas.printText(args[0].byteval!!.toString(), true)
@@ -733,10 +746,11 @@ class AstVm(val program: Program) {
                 }
                 val inputStr = input.joinToString("")
                 val heapId = args[0].wordval!!
-                val origStr = program.heap.get(heapId).str!!
-                val paddedStr=inputStr.padEnd(origStr.length+1, '\u0000').substring(0, origStr.length)
-                program.heap.update(heapId, paddedStr)
-                result = RuntimeValue(DataType.UBYTE, paddedStr.indexOf('\u0000'))
+                val origStrLength = getEncodedStringFromRuntimeVars(heapId).size
+                val encodedStr = Petscii.encodePetscii(inputStr, true).take(origStrLength).toMutableList()
+                while(encodedStr.size < origStrLength)
+                    encodedStr.add(0)
+                result = RuntimeValueNumeric(DataType.UBYTE, encodedStr.indexOf(0))
             }
             "c64flt.print_f" -> {
                 dialog.canvas.printText(args[0].floatval.toString(), false)
@@ -752,13 +766,13 @@ class AstVm(val program: Program) {
                     Thread.sleep(10)
                 }
                 val char=dialog.keyboardBuffer.pop()
-                result = RuntimeValue(DataType.UBYTE, char.toShort())
+                result = RuntimeValueNumeric(DataType.UBYTE, char.toShort())
             }
             "c64utils.str2uword" -> {
                 val heapId = args[0].wordval!!
-                val argString = program.heap.get(heapId).str!!
-                val numericpart = argString.takeWhile { it.isDigit() }
-                result = RuntimeValue(DataType.UWORD, numericpart.toInt() and 65535)
+                val argString = getEncodedStringFromRuntimeVars(heapId)
+                val numericpart = argString.takeWhile { it.toChar().isDigit() }.toString()
+                result = RuntimeValueNumeric(DataType.UWORD, numericpart.toInt() and 65535)
             }
             else -> TODO("syscall  ${sub.scopedname} $sub")
         }
@@ -766,144 +780,158 @@ class AstVm(val program: Program) {
         return result
     }
 
-    private fun performBuiltinFunction(name: String, args: List<RuntimeValue>, statusflags: StatusFlags): RuntimeValue? {
+    private fun getEncodedStringFromRuntimeVars(heapId: Int): List<Short> {
+        val stringvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueString
+        return when {
+            stringvar.type==DataType.STR -> Petscii.encodePetscii(stringvar.str, true)
+            stringvar.type==DataType.STR_S -> Petscii.encodeScreencode(stringvar.str, true)
+            else -> throw VmExecutionException("weird string type")
+        }
+    }
+
+    private fun getArrayFromRuntimeVars(heapId: Int): IntArray {
+        val arrayvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueArray
+        return arrayvar.array.map { it.toInt() }.toIntArray()
+    }
+
+    private fun performBuiltinFunction(name: String, args: List<RuntimeValueBase>, statusflags: StatusFlags): RuntimeValueNumeric? {
         return when (name) {
-            "rnd" -> RuntimeValue(DataType.UBYTE, rnd.nextInt() and 255)
-            "rndw" -> RuntimeValue(DataType.UWORD, rnd.nextInt() and 65535)
-            "rndf" -> RuntimeValue(DataType.FLOAT, rnd.nextDouble())
-            "lsb" -> RuntimeValue(DataType.UBYTE, args[0].integerValue() and 255)
-            "msb" -> RuntimeValue(DataType.UBYTE, (args[0].integerValue() ushr 8) and 255)
-            "sin" -> RuntimeValue(DataType.FLOAT, sin(args[0].numericValue().toDouble()))
+            "rnd" -> RuntimeValueNumeric(DataType.UBYTE, rnd.nextInt() and 255)
+            "rndw" -> RuntimeValueNumeric(DataType.UWORD, rnd.nextInt() and 65535)
+            "rndf" -> RuntimeValueNumeric(DataType.FLOAT, rnd.nextDouble())
+            "lsb" -> RuntimeValueNumeric(DataType.UBYTE, args[0].integerValue() and 255)
+            "msb" -> RuntimeValueNumeric(DataType.UBYTE, (args[0].integerValue() ushr 8) and 255)
+            "sin" -> RuntimeValueNumeric(DataType.FLOAT, sin(args[0].numericValue().toDouble()))
             "sin8" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (127.0 * sin(rad)).toShort())
+                RuntimeValueNumeric(DataType.BYTE, (127.0 * sin(rad)).toShort())
             }
             "sin8u" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort())
+                RuntimeValueNumeric(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort())
             }
             "sin16" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (32767.0 * sin(rad)).toShort())
+                RuntimeValueNumeric(DataType.BYTE, (32767.0 * sin(rad)).toShort())
             }
             "sin16u" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * sin(rad)).toShort())
+                RuntimeValueNumeric(DataType.UBYTE, (32768.0 + 32767.5 * sin(rad)).toShort())
             }
-            "cos" -> RuntimeValue(DataType.FLOAT, cos(args[0].numericValue().toDouble()))
+            "cos" -> RuntimeValueNumeric(DataType.FLOAT, cos(args[0].numericValue().toDouble()))
             "cos8" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (127.0 * cos(rad)).toShort())
+                RuntimeValueNumeric(DataType.BYTE, (127.0 * cos(rad)).toShort())
             }
             "cos8u" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort())
+                RuntimeValueNumeric(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort())
             }
             "cos16" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (32767.0 * cos(rad)).toShort())
+                RuntimeValueNumeric(DataType.BYTE, (32767.0 * cos(rad)).toShort())
             }
             "cos16u" -> {
                 val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * cos(rad)).toShort())
+                RuntimeValueNumeric(DataType.UBYTE, (32768.0 + 32767.5 * cos(rad)).toShort())
             }
-            "tan" -> RuntimeValue(DataType.FLOAT, tan(args[0].numericValue().toDouble()))
-            "atan" -> RuntimeValue(DataType.FLOAT, atan(args[0].numericValue().toDouble()))
-            "ln" -> RuntimeValue(DataType.FLOAT, ln(args[0].numericValue().toDouble()))
-            "log2" -> RuntimeValue(DataType.FLOAT, log2(args[0].numericValue().toDouble()))
-            "sqrt" -> RuntimeValue(DataType.FLOAT, sqrt(args[0].numericValue().toDouble()))
-            "sqrt16" -> RuntimeValue(DataType.UBYTE, sqrt(args[0].wordval!!.toDouble()).toInt())
-            "rad" -> RuntimeValue(DataType.FLOAT, Math.toRadians(args[0].numericValue().toDouble()))
-            "deg" -> RuntimeValue(DataType.FLOAT, Math.toDegrees(args[0].numericValue().toDouble()))
-            "round" -> RuntimeValue(DataType.FLOAT, round(args[0].numericValue().toDouble()))
-            "floor" -> RuntimeValue(DataType.FLOAT, floor(args[0].numericValue().toDouble()))
-            "ceil" -> RuntimeValue(DataType.FLOAT, ceil(args[0].numericValue().toDouble()))
+            "tan" -> RuntimeValueNumeric(DataType.FLOAT, tan(args[0].numericValue().toDouble()))
+            "atan" -> RuntimeValueNumeric(DataType.FLOAT, atan(args[0].numericValue().toDouble()))
+            "ln" -> RuntimeValueNumeric(DataType.FLOAT, ln(args[0].numericValue().toDouble()))
+            "log2" -> RuntimeValueNumeric(DataType.FLOAT, log2(args[0].numericValue().toDouble()))
+            "sqrt" -> RuntimeValueNumeric(DataType.FLOAT, sqrt(args[0].numericValue().toDouble()))
+            "sqrt16" -> RuntimeValueNumeric(DataType.UBYTE, sqrt((args[0] as RuntimeValueNumeric).wordval!!.toDouble()).toInt())
+            "rad" -> RuntimeValueNumeric(DataType.FLOAT, Math.toRadians(args[0].numericValue().toDouble()))
+            "deg" -> RuntimeValueNumeric(DataType.FLOAT, Math.toDegrees(args[0].numericValue().toDouble()))
+            "round" -> RuntimeValueNumeric(DataType.FLOAT, round(args[0].numericValue().toDouble()))
+            "floor" -> RuntimeValueNumeric(DataType.FLOAT, floor(args[0].numericValue().toDouble()))
+            "ceil" -> RuntimeValueNumeric(DataType.FLOAT, ceil(args[0].numericValue().toDouble()))
             "rol" -> {
-                val (result, newCarry) = args[0].rol(statusflags.carry)
+                val (result, newCarry) = (args[0] as RuntimeValueNumeric).rol(statusflags.carry)
                 statusflags.carry = newCarry
                 return result
             }
-            "rol2" -> args[0].rol2()
+            "rol2" -> (args[0] as RuntimeValueNumeric).rol2()
             "ror" -> {
-                val (result, newCarry) = args[0].ror(statusflags.carry)
+                val (result, newCarry) = (args[0] as RuntimeValueNumeric).ror(statusflags.carry)
                 statusflags.carry = newCarry
                 return result
             }
-            "ror2" -> args[0].ror2()
-            "lsl" -> args[0].shl()
-            "lsr" -> args[0].shr()
+            "ror2" -> (args[0] as RuntimeValueNumeric).ror2()
+            "lsl" -> (args[0] as RuntimeValueNumeric).shl()
+            "lsr" -> (args[0] as RuntimeValueNumeric).shr()
             "abs" -> {
                 when (args[0].type) {
-                    DataType.UBYTE -> args[0]
-                    DataType.BYTE -> RuntimeValue(DataType.UBYTE, abs(args[0].numericValue().toDouble()))
-                    DataType.UWORD -> args[0]
-                    DataType.WORD -> RuntimeValue(DataType.UWORD, abs(args[0].numericValue().toDouble()))
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(args[0].numericValue().toDouble()))
+                    DataType.UBYTE -> (args[0]  as RuntimeValueNumeric)
+                    DataType.BYTE -> RuntimeValueNumeric(DataType.UBYTE, abs(args[0].numericValue().toDouble()))
+                    DataType.UWORD -> (args[0] as RuntimeValueNumeric)
+                    DataType.WORD -> RuntimeValueNumeric(DataType.UWORD, abs(args[0].numericValue().toDouble()))
+                    DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, abs(args[0].numericValue().toDouble()))
                     else -> throw VmExecutionException("strange abs type ${args[0]}")
                 }
             }
             "max" -> {
-                val numbers = args.single().array!!.map { it.toDouble() }
-                RuntimeValue(ArrayElementTypes.getValue(args[0].type), numbers.max())
+                val numbers = (args.single() as RuntimeValueArray).array.map { it.toDouble() }
+                RuntimeValueNumeric(ArrayElementTypes.getValue(args[0].type), numbers.max()!!)
             }
             "min" -> {
-                val numbers = args.single().array!!.map { it.toDouble() }
-                RuntimeValue(ArrayElementTypes.getValue(args[0].type), numbers.min())
+                val numbers = (args.single() as RuntimeValueArray).array.map { it.toDouble() }
+                RuntimeValueNumeric(ArrayElementTypes.getValue(args[0].type), numbers.min()!!)
             }
             "sum" -> {
-                val sum = args.single().array!!.map { it.toDouble() }.sum()
+                val sum = (args.single() as RuntimeValueArray).array.map { it.toDouble() }.sum()
                 when (args[0].type) {
-                    DataType.ARRAY_UB -> RuntimeValue(DataType.UWORD, sum)
-                    DataType.ARRAY_B -> RuntimeValue(DataType.WORD, sum)
-                    DataType.ARRAY_UW -> RuntimeValue(DataType.UWORD, sum)
-                    DataType.ARRAY_W -> RuntimeValue(DataType.WORD, sum)
-                    DataType.ARRAY_F -> RuntimeValue(DataType.FLOAT, sum)
+                    DataType.ARRAY_UB -> RuntimeValueNumeric(DataType.UWORD, sum)
+                    DataType.ARRAY_B -> RuntimeValueNumeric(DataType.WORD, sum)
+                    DataType.ARRAY_UW -> RuntimeValueNumeric(DataType.UWORD, sum)
+                    DataType.ARRAY_W -> RuntimeValueNumeric(DataType.WORD, sum)
+                    DataType.ARRAY_F -> RuntimeValueNumeric(DataType.FLOAT, sum)
                     else -> throw VmExecutionException("weird sum type ${args[0]}")
                 }
             }
             "any" -> {
-                val numbers = args.single().array!!.map { it.toDouble() }
-                RuntimeValue(DataType.UBYTE, if (numbers.any { it != 0.0 }) 1 else 0)
+                val numbers = (args.single() as RuntimeValueArray).array.map { it.toDouble() }
+                RuntimeValueNumeric(DataType.UBYTE, if (numbers.any { it != 0.0 }) 1 else 0)
             }
             "all" -> {
-                val numbers = args.single().array!!.map { it.toDouble() }
-                RuntimeValue(DataType.UBYTE, if (numbers.all { it != 0.0 }) 1 else 0)
+                val numbers = (args.single() as RuntimeValueArray).array.map { it.toDouble() }
+                RuntimeValueNumeric(DataType.UBYTE, if (numbers.all { it != 0.0 }) 1 else 0)
             }
             "swap" ->
                 throw VmExecutionException("swap() cannot be implemented as a function")
             "strlen" -> {
-                val zeroIndex = args[0].str!!.indexOf(0.toChar())
+                val zeroIndex = (args[0] as RuntimeValueString).str.indexOf(0.toChar())
                 if (zeroIndex >= 0)
-                    RuntimeValue(DataType.UBYTE, zeroIndex)
+                    RuntimeValueNumeric(DataType.UBYTE, zeroIndex)
                 else
-                    RuntimeValue(DataType.UBYTE, args[0].str!!.length)
+                    RuntimeValueNumeric(DataType.UBYTE, (args[0] as RuntimeValueString).str.length)
             }
             "memset" -> {
-                val heapId = args[0].wordval!!
-                val target = program.heap.get(heapId).array ?: throw VmExecutionException("memset target is not an array")
+                val heapId = (args[0] as RuntimeValueNumeric).wordval!!
+                val target = getArrayFromRuntimeVars(heapId)
                 val amount = args[1].integerValue()
                 val value = args[2].integerValue()
                 for (i in 0 until amount) {
-                    target[i] = IntegerOrAddressOf(value, null)
+                    target[i] = value
                 }
                 null
             }
             "memsetw" -> {
-                val heapId = args[0].wordval!!
-                val target = program.heap.get(heapId).array  ?: throw VmExecutionException("memset target is not an array")
+                val heapId = (args[0] as RuntimeValueNumeric).wordval!!
+                val target = getArrayFromRuntimeVars(heapId)
                 val amount = args[1].integerValue()
                 val value = args[2].integerValue()
                 for (i in 0 until amount step 2) {
-                    target[i * 2] = IntegerOrAddressOf(value and 255, null)
-                    target[i * 2 + 1] = IntegerOrAddressOf(value ushr 8, null)
+                    target[i * 2] = value and 255
+                    target[i * 2 + 1] = value ushr 8
                 }
                 null
             }
             "memcopy" -> {
-                val sourceHeapId = args[0].wordval!!
-                val destHeapId = args[1].wordval!!
-                val source = program.heap.get(sourceHeapId).array!!
-                val dest = program.heap.get(destHeapId).array!!
+                val sourceHeapId = (args[0] as RuntimeValueNumeric).wordval!!
+                val destHeapId = (args[1] as RuntimeValueNumeric).wordval!!
+                val source = getArrayFromRuntimeVars(sourceHeapId)
+                val dest = getArrayFromRuntimeVars(destHeapId)
                 val amount = args[2].integerValue()
                 for(i in 0 until amount) {
                     dest[i] = source[i]
@@ -912,7 +940,7 @@ class AstVm(val program: Program) {
             }
             "mkword" -> {
                 val result = (args[1].integerValue() shl 8) or args[0].integerValue()
-                RuntimeValue(DataType.UWORD, result)
+                RuntimeValueNumeric(DataType.UWORD, result)
             }
             "set_carry" -> {
                 statusflags.carry=true
@@ -935,13 +963,13 @@ class AstVm(val program: Program) {
                 val zero = if(statusflags.zero) 2 else 0
                 val irqd = if(statusflags.irqd) 4 else 0
                 val negative = if(statusflags.negative) 128 else 0
-                RuntimeValue(DataType.UBYTE, carry or zero or irqd or negative)
+                RuntimeValueNumeric(DataType.UBYTE, carry or zero or irqd or negative)
             }
             "rsave" -> {
                 statusFlagsSave.push(statusflags)
-                registerAsave.push(runtimeVariables.get(program.namespace, Register.A.name))
-                registerXsave.push(runtimeVariables.get(program.namespace, Register.X.name))
-                registerYsave.push(runtimeVariables.get(program.namespace, Register.Y.name))
+                registerAsave.push(runtimeVariables.get(program.namespace, Register.A.name) as RuntimeValueNumeric)
+                registerXsave.push(runtimeVariables.get(program.namespace, Register.X.name) as RuntimeValueNumeric)
+                registerYsave.push(runtimeVariables.get(program.namespace, Register.Y.name) as RuntimeValueNumeric)
                 null
             }
             "rrestore" -> {
@@ -955,8 +983,25 @@ class AstVm(val program: Program) {
                 runtimeVariables.set(program.namespace, Register.Y.name, registerYsave.pop())
                 null
             }
+            "sort" -> {
+                val array=args.single() as RuntimeValueArray
+                array.array.sort()
+                null
+            }
+            "reverse" -> {
+                val array=args.single() as RuntimeValueArray
+                array.array.reverse()
+                null
+            }
+            "sgn" -> {
+                val value = args.single().numericValue().toDouble()
+                when {
+                    value<0.0 -> RuntimeValueNumeric(DataType.BYTE, -1)
+                    value==0.0 -> RuntimeValueNumeric(DataType.BYTE, 0)
+                    else -> RuntimeValueNumeric(DataType.BYTE, 1)
+                }
+            }
             else -> TODO("builtin function $name")
         }
     }
-
 }

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

@@ -10,12 +10,11 @@ import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
 import prog8.ast.statements.Label
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.VarDecl
-import prog8.vm.RuntimeValue
-import prog8.vm.RuntimeValueRange
+import prog8.vm.*
 
 
-typealias BuiltinfunctionCaller =  (name: String, args: List<RuntimeValue>, flags: StatusFlags) -> RuntimeValue?
-typealias SubroutineCaller =  (sub: Subroutine, args: List<RuntimeValue>, startAtLabel: Label?) -> RuntimeValue?
+typealias BuiltinfunctionCaller =  (name: String, args: List<RuntimeValueNumeric>, flags: StatusFlags) -> RuntimeValueNumeric?
+typealias SubroutineCaller =  (sub: Subroutine, args: List<RuntimeValueNumeric>, startAtLabel: Label?) -> RuntimeValueNumeric?
 
 
 class EvalContext(val program: Program, val mem: Memory, val statusflags: StatusFlags,
@@ -23,34 +22,34 @@ class EvalContext(val program: Program, val mem: Memory, val statusflags: Status
                   val performBuiltinFunction: BuiltinfunctionCaller,
                   val executeSubroutine: SubroutineCaller)
 
-fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
+fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase {
     val constval = expr.constValue(ctx.program)
     if(constval!=null)
-        return RuntimeValue.fromLv(constval)
+        return RuntimeValueNumeric.fromLv(constval)
 
     when(expr) {
-        is NumericLiteralValue -> return RuntimeValue.fromLv(expr)
-        is StringLiteralValue -> return RuntimeValue.fromLv(expr, ctx.program.heap)
-        is ArrayLiteralValue -> return RuntimeValue.fromLv(expr, ctx.program.heap)
+        is NumericLiteralValue -> return RuntimeValueNumeric.fromLv(expr)
+        is StringLiteralValue -> return RuntimeValueString.fromLv(expr)
+        is ArrayLiteralValue -> return RuntimeValueArray.fromLv(expr)
         is PrefixExpression -> {
             return when(expr.operator) {
-                "-" -> evaluate(expr.expression, ctx).neg()
-                "~" -> evaluate(expr.expression, ctx).inv()
-                "not" -> evaluate(expr.expression, ctx).not()
+                "-" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).neg()
+                "~" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).inv()
+                "not" -> (evaluate(expr.expression, ctx) as RuntimeValueNumeric).not()
                 // unary '+' should have been optimized away
                 else -> throw VmExecutionException("unsupported prefix operator "+expr.operator)
             }
         }
         is BinaryExpression -> {
-            val left = evaluate(expr.left, ctx)
-            val right = evaluate(expr.right, ctx)
+            val left = evaluate(expr.left, ctx) as RuntimeValueNumeric
+            val right = evaluate(expr.right, ctx) as RuntimeValueNumeric
             return when(expr.operator) {
-                "<" -> RuntimeValue(DataType.UBYTE, if (left < right) 1 else 0)
-                "<=" -> RuntimeValue(DataType.UBYTE, if (left <= right) 1 else 0)
-                ">" -> RuntimeValue(DataType.UBYTE, if (left > right) 1 else 0)
-                ">=" -> RuntimeValue(DataType.UBYTE, if (left >= right) 1 else 0)
-                "==" -> RuntimeValue(DataType.UBYTE, if (left == right) 1 else 0)
-                "!=" -> RuntimeValue(DataType.UBYTE, if (left != right) 1 else 0)
+                "<" -> RuntimeValueNumeric(DataType.UBYTE, if (left < right) 1 else 0)
+                "<=" -> RuntimeValueNumeric(DataType.UBYTE, if (left <= right) 1 else 0)
+                ">" -> RuntimeValueNumeric(DataType.UBYTE, if (left > right) 1 else 0)
+                ">=" -> RuntimeValueNumeric(DataType.UBYTE, if (left >= right) 1 else 0)
+                "==" -> RuntimeValueNumeric(DataType.UBYTE, if (left == right) 1 else 0)
+                "!=" -> RuntimeValueNumeric(DataType.UBYTE, if (left != right) 1 else 0)
                 "+" -> left.add(right)
                 "-" -> left.sub(right)
                 "*" -> left.mul(right)
@@ -78,27 +77,36 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
         }
         is ArrayIndexedExpression -> {
             val array = evaluate(expr.identifier, ctx)
-            val index = evaluate(expr.arrayspec.index, ctx)
-            val value = array.array!![index.integerValue()]
-            return RuntimeValue(ArrayElementTypes.getValue(array.type), value)
+            val index = evaluate(expr.arrayspec.index, ctx) as RuntimeValueNumeric
+            return when (array) {
+                is RuntimeValueString -> {
+                    val value = array.str[index.integerValue()]
+                    RuntimeValueNumeric(ArrayElementTypes.getValue(array.type), value.toShort())
+                }
+                is RuntimeValueArray -> {
+                    val value = array.array[index.integerValue()]
+                    RuntimeValueNumeric(ArrayElementTypes.getValue(array.type), value)
+                }
+                else -> throw VmExecutionException("weird type")
+            }
         }
         is TypecastExpression -> {
-            return evaluate(expr.expression, ctx).cast(expr.type)
+            return (evaluate(expr.expression, ctx) as RuntimeValueNumeric).cast(expr.type)
         }
         is AddressOf -> {
             // we support: address of heap var -> the heap id
             return try {
                 val heapId = expr.identifier.heapId(ctx.program.namespace)
-                RuntimeValue(DataType.UWORD, heapId)
+                RuntimeValueNumeric(DataType.UWORD, heapId)
             } catch( f: FatalAstException) {
                 // fallback: use the hash of the name, so we have at least *a* value...
                 val address = expr.identifier.hashCode() and 65535
-                RuntimeValue(DataType.UWORD, address)
+                RuntimeValueNumeric(DataType.UWORD, address)
             }
         }
         is DirectMemoryRead -> {
-            val address = evaluate(expr.addressExpression, ctx).wordval!!
-            return RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
+            val address = (evaluate(expr.addressExpression, ctx) as RuntimeValueNumeric).wordval!!
+            return RuntimeValueNumeric(DataType.UBYTE, ctx.mem.getUByte(address))
         }
         is RegisterExpr -> return ctx.runtimeVars.get(ctx.program.namespace, expr.register.name)
         is IdentifierReference -> {
@@ -111,13 +119,13 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
                     else -> {
                         val address = ctx.runtimeVars.getMemoryAddress(variable.definingScope(), variable.name)
                         return when(variable.datatype) {
-                            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
-                            DataType.BYTE -> RuntimeValue(DataType.BYTE, ctx.mem.getSByte(address))
-                            DataType.UWORD -> RuntimeValue(DataType.UWORD, ctx.mem.getUWord(address))
-                            DataType.WORD -> RuntimeValue(DataType.WORD, ctx.mem.getSWord(address))
-                            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, ctx.mem.getFloat(address))
-                            DataType.STR -> RuntimeValue(DataType.STR, str = ctx.mem.getString(address))
-                            DataType.STR_S -> RuntimeValue(DataType.STR_S, str = ctx.mem.getScreencodeString(address))
+                            DataType.UBYTE -> RuntimeValueNumeric(DataType.UBYTE, ctx.mem.getUByte(address))
+                            DataType.BYTE -> RuntimeValueNumeric(DataType.BYTE, ctx.mem.getSByte(address))
+                            DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, ctx.mem.getUWord(address))
+                            DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address))
+                            DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address))
+                            DataType.STR -> RuntimeValueString(DataType.STR, ctx.mem.getString(address), null)
+                            DataType.STR_S -> RuntimeValueString(DataType.STR_S, ctx.mem.getScreencodeString(address)!!, null)
                             else -> throw VmExecutionException("unexpected datatype $variable")
                         }
                     }
@@ -127,7 +135,7 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
         }
         is FunctionCall -> {
             val sub = expr.target.targetStatement(ctx.program.namespace)
-            val args = expr.arglist.map { evaluate(it, ctx) }
+            val args = expr.arglist.map { evaluate(it, ctx) as RuntimeValueNumeric }
             return when(sub) {
                 is Subroutine -> {
                     val result = ctx.executeSubroutine(sub, args, null)
@@ -153,9 +161,9 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValue {
                 else
                     throw VmExecutionException("couldn't determine datatype")
             }
-            val fromVal = evaluate(expr.from, ctx).integerValue()
-            val toVal = evaluate(expr.to, ctx).integerValue()
-            val stepVal = evaluate(expr.step, ctx).integerValue()
+            val fromVal = (evaluate(expr.from, ctx) as RuntimeValueNumeric).integerValue()
+            val toVal = (evaluate(expr.to, ctx) as RuntimeValueNumeric).integerValue()
+            val stepVal = (evaluate(expr.step, ctx) as RuntimeValueNumeric).integerValue()
             val range = makeRange(fromVal, toVal, stepVal)
             val dt = expr.inferType(ctx.program)
             if(dt.isKnown)

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

@@ -75,6 +75,10 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         }
     }
 
+    fun printText(text: Iterable<Short>) {
+        text.forEach { printPetscii(it, false) }
+    }
+
     fun printPetscii(char: Short, inverseVideo: Boolean=false) {
         if(char==13.toShort() || char==141.toShort()) {
             cursorX=0

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

@@ -13,16 +13,17 @@ import prog8.ast.statements.Statement
 import prog8.ast.statements.StructDecl
 import prog8.ast.statements.VarDecl
 import prog8.ast.statements.ZeropageWish
-import prog8.compiler.HeapValues
-import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueArray
+import prog8.vm.RuntimeValueNumeric
+import prog8.vm.RuntimeValueString
 
-class VariablesCreator(private val runtimeVariables: RuntimeVariables, private val heap: HeapValues) : IAstModifyingVisitor {
+class VariablesCreator(private val runtimeVariables: RuntimeVariables) : IAstModifyingVisitor {
 
     override fun visit(program: Program) {
         // define the three registers as global variables
-        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValue(DataType.UBYTE, 0))
-        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValue(DataType.UBYTE, 255))
-        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValue(DataType.UBYTE, 0))
+        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValueNumeric(DataType.UBYTE, 0))
+        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValueNumeric(DataType.UBYTE, 255))
+        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValueNumeric(DataType.UBYTE, 0))
 
         val globalpos = Position("<<global>>", 0, 0, 0)
         val vdA = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.A.name, null,
@@ -49,12 +50,19 @@ class VariablesCreator(private val runtimeVariables: RuntimeVariables, private v
                     if(decl.datatype!=DataType.STRUCT) {
                         val numericLv = decl.value as? NumericLiteralValue
                         val value = if(numericLv!=null) {
-                            RuntimeValue.fromLv(numericLv)
+                            RuntimeValueNumeric.fromLv(numericLv)
                         } else {
-                            if(decl.value is StringLiteralValue)
-                                RuntimeValue.fromLv(decl.value as StringLiteralValue, heap)
-                            else
-                                RuntimeValue.fromLv(decl.value as ArrayLiteralValue, heap)
+                            val strLv = decl.value as? StringLiteralValue
+                            val arrayLv = decl.value as? ArrayLiteralValue
+                            when {
+                                strLv!=null -> {
+                                    RuntimeValueString.fromLv(strLv)
+                                }
+                                arrayLv!=null -> {
+                                    RuntimeValueArray.fromLv(arrayLv)
+                                }
+                                else -> throw VmExecutionException("weird var type")
+                            }
                         }
                         runtimeVariables.define(decl.definingScope(), decl.name, value)
                     }
@@ -69,12 +77,4 @@ class VariablesCreator(private val runtimeVariables: RuntimeVariables, private v
         }
         return super.visit(decl)
     }
-
-//    override fun accept(assignment: Assignment): Statement {
-//        if(assignment is VariableInitializationAssignment) {
-//            println("INIT VAR $assignment")
-//        }
-//        return super.accept(assignment)
-//    }
-
 }

compiler/test/LiteralValueTests.kt

@@ -83,8 +83,8 @@ class TestParserNumericLiteralValue {
 
     @Test
     fun testEqualsRef() {
-        assertTrue(StringLiteralValue(DataType.STR, "hello", position = dummyPos) == StringLiteralValue(DataType.STR, "hello", position = dummyPos))
-        assertFalse(StringLiteralValue(DataType.STR, "hello", position = dummyPos) == StringLiteralValue(DataType.STR, "bye", position = dummyPos))
+        assertTrue(StringLiteralValue(DataType.STR, "hello", dummyPos) == StringLiteralValue(DataType.STR, "hello", dummyPos))
+        assertFalse(StringLiteralValue(DataType.STR, "hello", dummyPos) == StringLiteralValue(DataType.STR, "bye", dummyPos))
 
         val lvOne = NumericLiteralValue(DataType.UBYTE, 1, dummyPos)
         val lvTwo = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
@@ -93,9 +93,9 @@ class TestParserNumericLiteralValue {
         val lvTwoR = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
         val lvThreeR = NumericLiteralValue(DataType.UBYTE, 3, dummyPos)
         val lvFour= NumericLiteralValue(DataType.UBYTE, 4, dummyPos)
-        val lv1 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOne, lvTwo, lvThree), position = dummyPos)
-        val lv2 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvThreeR), position = dummyPos)
-        val lv3 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvFour), position = dummyPos)
+        val lv1 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOne, lvTwo, lvThree), null, dummyPos)
+        val lv2 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvThreeR), null, dummyPos)
+        val lv3 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvFour), null, dummyPos)
         assertEquals(lv1, lv2)
         assertNotEquals(lv1, lv3)
     }

compiler/test/RuntimeValueTests.kt

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

compiler/test/UnitTests.kt

@@ -15,11 +15,10 @@ import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
 import prog8.compiler.target.c64.MachineDefinition.Mflpt5
 import prog8.compiler.target.c64.Petscii
-import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueNumeric
 import java.io.CharConversionException
 import kotlin.test.*
 
-
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestCompiler {
     @Test
@@ -54,7 +53,6 @@ class TestCompiler {
         assertFailsWith<CompilerException> { 65536L.toHex()  }
     }
 
-
     @Test
     fun testFloatToMflpt5() {
         assertThat(Mflpt5.fromNumber(0), equalTo(Mflpt5(0x00, 0x00, 0x00, 0x00, 0x00)))
@@ -371,8 +369,8 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = StringLiteralValue(DataType.STR, "abc", position = Position("", 0, 0, 0))
-        val abd = StringLiteralValue(DataType.STR, "abd", position = Position("", 0, 0, 0))
+        val abc = StringLiteralValue(DataType.STR, "abc", Position("", 0, 0, 0))
+        val abd = StringLiteralValue(DataType.STR, "abd", Position("", 0, 0, 0))
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)
@@ -380,8 +378,8 @@ class TestPetscii {
 
     @Test
     fun testStackvmValueComparisons() {
-        val ten = RuntimeValue(DataType.FLOAT, 10)
-        val nine = RuntimeValue(DataType.UWORD, 9)
+        val ten = RuntimeValueNumeric(DataType.FLOAT, 10)
+        val nine = RuntimeValueNumeric(DataType.UWORD, 9)
         assertEquals(ten, ten)
         assertNotEquals(ten, nine)
         assertFalse(ten != ten)

docs/source/building.rst

@@ -94,6 +94,13 @@ Start the compiler with the ``-watch`` argument to enable this.
 It will compile your program and then instead of exiting, it waits for any changes in the module source files.
 As soon as a change happens, the program gets compiled again.
 
+Other options
+^^^^^^^^^^^^^
+There's an option to specify the output directory if you're not happy with the default (the current working directory).
+Also it is possible to specify more than one main module to compile:
+this can be useful to quickly recompile multiple separate programs quickly.
+(compiling in a batch like this is a lot faster than invoking the compiler again once per main file)
+
 
 Module source code files
 ------------------------
@@ -163,22 +170,16 @@ or::
 
 
 
-Virtual Machine
----------------
+Virtual Machine / Simulator
+---------------------------
 
-You may have noticed the ``-avm`` and ``-vm`` command line options for the compiler:
+You may have noticed the ``-sim`` command line option for the compiler:
 
--avm
-    Launches the "AST virtual machine" that directly executes the parsed program.
+-sim
+    Launches the "AST virtual machine Simulator" that directly executes the parsed program.
     No compilation steps will be performed.
     Allows for very fast testing and debugging before actually compiling programs
     to machine code.
     It simulates a bare minimum of features from the target platform, so most stuff
     that calls ROM routines or writes into hardware registers won't work. But basic
     system routines are emulated.
-
--vm   <vm bytecode file>
-    Launches the "intermediate code VM"
-    it interprets the intermediate code that the compiler can write when using the ``-writevm``
-    option. This is the code that will be fed to the assembly code generator,
-    so you'll skip that last step.

docs/source/programming.rst

@@ -768,7 +768,7 @@ rol(x)
     Modifies in-place, doesn't return a value (so can't be used in an expression).
 
 rol2(x)
-    Like _rol but now as 8-bit or 16-bit rotation.
+    Like ``rol`` but now as 8-bit or 16-bit rotation.
     It uses some extra logic to not consider the carry flag as extra rotation bit.
     Modifies in-place, doesn't return a value (so can't be used in an expression).
 
@@ -780,7 +780,7 @@ ror(x)
     Modifies in-place, doesn't return a value (so can't be used in an expression).
 
 ror2(x)
-    Like _ror but now as 8-bit or 16-bit rotation.
+    Like ``ror`` but now as 8-bit or 16-bit rotation.
     It uses some extra logic to not consider the carry flag as extra rotation bit.
     Modifies in-place, doesn't return a value (so can't be used in an expression).
 

docs/source/todo.rst

@@ -44,6 +44,15 @@ Allocate a fixed word in ZP that is the TOS so we can always operate on TOS dire
 without having to to index into the stack?
 
 
+Bugs
+^^^^
+There are a few erroneous compiler errors when dealing with certain for loops::
+
+    for bb in [1,2,3]   ;  byte loop variable can only loop over bytes
+    for ww in [1111,3333,555,999]  ; word loop variable can only loop over bytes or words
+    for uw in 20 to 10 step -1  ; 'can't cast BYTE into UWORD'
+
+
 Misc
 ^^^^
 

examples/arithmetic/bitshift.p8

@@ -11,15 +11,22 @@ main {
     uword uw
     &ubyte  membyte=9999
     &uword  memword=9999
-    ubyte[10] barray
+    ubyte[10] ubarray
+    uword[10] uwarray
+    byte[10] bbarray
+    word[10] wwarray
 
     sub start() {
-        lsr(A)
-        lsl(A)
-        ror(A)
-        rol(A)
-        ror2(A)
-        rol2(A)
+;        lsr(A)
+;        lsl(A)
+;        ror(A)
+;        rol(A)
+;        ror2(A)
+;        rol2(A)
+
+        lsr(bb)
+        lsl(bb)
+
         lsr(membyte)
         lsl(membyte)
         ror(membyte)
@@ -32,18 +39,38 @@ main {
         rol(memword)
         ror2(memword)
         rol2(memword)
+
         lsl(@(9999))
         lsr(@(9999))
         ror(@(9999))
         rol(@(9999))
         ror2(@(9999))
         rol2(@(9999))
-        lsr(barray[1])
-        lsl(barray[1])
-        ror(barray[1])
-        rol(barray[1])
-        ror2(barray[1])
-        rol2(barray[1])
+
+        lsl(@(9999+A))
+        lsr(@(9999+A))
+        ror(@(9999+A))
+        rol(@(9999+A))
+        ror2(@(9999+A))
+        rol2(@(9999+A))
+
+        lsr(ubarray[1])
+        lsl(ubarray[1])
+        ror(ubarray[1])
+        rol(ubarray[1])
+        ror2(ubarray[1])
+        rol2(ubarray[1])
+        lsr(bbarray[1])
+        lsl(bbarray[1])
+
+        lsr(uwarray[1])
+        lsl(uwarray[1])
+        ror(uwarray[1])
+        rol(uwarray[1])
+        ror2(uwarray[1])
+        rol2(uwarray[1])
+        lsr(wwarray[1])
+        lsl(wwarray[1])
 
 
         bb /= 2

examples/comparison_ifs_word.p8

@@ -106,6 +106,39 @@ main {
         else
             c64scr.print("error in -222>=-222!\n")
 
+        v1 = 1000
+        v2 = 1000
+        if v1==v2
+            c64scr.print("ok: 1000 == 1000\n")
+        else
+            c64scr.print("error in 1000==1000!\n")
+
+        if v1!=v2
+            c64scr.print("error in 1000!=1000!\n")
+        else
+            c64scr.print("ok: 1000 is not != 1000\n")
+
+        if v1<v2
+            c64scr.print("error in 1000<1000!\n")
+        else
+            c64scr.print("ok: 1000 is not < 1000\n")
+
+        if v1<=v2
+            c64scr.print("ok: 1000 <= 1000\n")
+        else
+            c64scr.print("error in 1000<=1000!\n")
+
+        if v1>v2
+            c64scr.print("error in 1000>1000!\n")
+        else
+            c64scr.print("ok: 1000 is not > 1000\n")
+
+        if v1>=v2
+            c64scr.print("ok: 1000 >= 1000\n")
+        else
+            c64scr.print("error in 1000>=1000!\n")
+
+
         ubyte endX = X
         if endX == 255
             c64scr.print("stack x ok!\n")

examples/test.p8

@@ -1,23 +1,63 @@
-%import c64lib
-%import c64utils
 %zeropage basicsafe
 
+; TODO fix compiler errors:
+; for bb in [1,2,3] -> byte loop variable can only loop over bytes
+; for ww in [1111,3333,555,999] -> word loop variable can only loop over bytes or words
+; for uw in 20 to 10 step -1   ->  'can't cast BYTE into UWORD'
+
 main {
 
     sub start() {
+        ubyte[] ubarr = [22,33,44,55,66]
+        byte[] barr = [22,-33,-44,55,66]
+        ubyte endub1
+        byte endb1
+        uword count
+        ubyte aa
+        ubyte ub
+        byte bb
+        word total
 
-        const ubyte i = 33
 
-        i=33
-        i++
-        const ubyte q=33
-        for q in [1,3,5,99] {
-            A=i
+        for count in 10 to 20 step 1 {
+        }
+        for count in 20 to 10 step -1 {     ; @todo fix compiler error
         }
 
-        while q<10 {
-            q++
+        ; ---------- BYTE var ---------
+
+        ; @todo fix  byte loop in arrayliteral 'Error: byte loop variable can only loop over bytes'
+        count = 0
+        total = 0
+        c64scr.print("byte var in arrayliteral: ")
+        for bb in [1,3,5,99] {
+            count++
+            total += bb
         }
+        if count==4 and total==108
+            c64scr.print("ok\n")
+        else
+            c64scr.print("fail!!!\n")
+
+
+        ; ---------- WORD var ---------
+
+        word[] warr = [-111,222,-333,444]
+        word endw1
+        word ww
+
+        ; @todo fix compiler error
+        count = 0
+        total = 0
+        c64scr.print("word var in arrayliteral: ")
+        for ww in [1111,3333,555,999] {
+            count++
+            total += ww
+        }
+        if count==4 and total==5998
+            c64scr.print("ok\n")
+        else
+            c64scr.print("fail!!!\n")
 
     }
 }

gradle.properties

@@ -4,4 +4,4 @@ org.gradle.parallel=true
 org.gradle.jvmargs=-Xmx2500M
 org.gradle.daemon=true
 
-kotlinVersion=1.3.41
+kotlinVersion=1.3.50

scripts/create_compiler_jar.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-
-# this script uses the Gradle build to compile the code,
-# and then adds the contents of several jar files into one output jar.
-
-./gradlew jar
-
-mkdir -p compiler_jar/extracted
-mkdir -p compiler_jar/source
-cp compiler/build/libs/compiler.jar parser/build/libs/parser.jar parser/antlr/lib/antlr-runtime-4.7.2.jar compiler_jar/source/
-
-KOTLINLIBS=$(kotlinc -verbose -script 2>&1 | grep home | cut -d ' ' -f 6-)/lib
-cp ${KOTLINLIBS}/kotlin-stdlib-jdk8.jar ${KOTLINLIBS}/kotlin-stdlib.jar compiler_jar/source/
-
-pushd compiler_jar/extracted
-for i in ../source/*.jar; do jar xf $i; done
-cd ..
-jar cfe ../prog8compiler.jar prog8.CompilerMainKt -C extracted .
-popd
-rm -r compiler_jar
-ls -l prog8compiler.jar