version 9.4

Added IR SQUARE instruction.

.idea/libraries/antlr_antlr4.xml

@@ -1,13 +1,13 @@
 <component name="libraryTable">
   <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.13.0">
+    <properties maven-id="org.antlr:antlr4:4.12.0">
       <exclude>
         <dependency maven-id="com.ibm.icu:icu4j" />
       </exclude>
     </properties>
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.13.0/antlr4-4.13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.13.0/antlr4-runtime-4.13.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.12.0/antlr4-4.12.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.12.0/antlr4-runtime-4.12.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.3/antlr-runtime-3.5.3.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.4/ST4-4.3.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />

.idea/libraries/io_kotest_property_jvm.xml

@@ -1,24 +0,0 @@
-<component name="libraryTable">
-  <library name="io.kotest.property.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-property-jvm:5.6.2" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.6.2/kotest-property-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/curious-odd-man/rgxgen/1.4/rgxgen-1.4.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.6.2/kotest-common-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.6.2/kotest-assertions-shared-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.6.2/kotest-assertions-api-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

README.md

@@ -74,6 +74,8 @@ What does Prog8 provide?
 - "c64": Commodore-64  (6502 like CPU)
 - "c128": Commodore-128  (6502 like CPU - the Z80 cpu mode is not supported)
 - "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)
+- "pet32": Commodore PET (experimental)
+- "atari": Atari 8 bit such as 800XL (experimental)
 - If you only use standard kernal and prog8 library routines, it is possible to compile the *exact same program* for different machines (just change the compiler target flag)
 
 

codeCore/src/prog8/code/SymbolTable.kt

@@ -213,8 +213,7 @@ class StStaticVariable(name: String,
 
 
 class StConstant(name: String, val dt: DataType, val value: Double, astNode: PtNode) :
-    StNode(name, StNodeType.CONSTANT, astNode) {
-}
+    StNode(name, StNodeType.CONSTANT, astNode)
 
 
 class StMemVar(name: String,
@@ -236,12 +235,11 @@ class StMemorySlab(
     val align: UInt,
     astNode: PtNode
 ):
-    StNode(name, StNodeType.MEMORYSLAB, astNode) {
-}
+    StNode(name, StNodeType.MEMORYSLAB, astNode)
+
 
 class StSub(name: String, val parameters: List<StSubroutineParameter>, val returnType: DataType?, astNode: PtNode) :
-        StNode(name, StNodeType.SUBROUTINE, astNode) {
-}
+        StNode(name, StNodeType.SUBROUTINE, astNode)
 
 
 class StRomSub(name: String,

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -26,8 +26,6 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                 PtMemMapped("P8ZP_SCRATCH_REG", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_REG, null, Position.DUMMY),
                 PtMemMapped("P8ZP_SCRATCH_W1", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W1, null, Position.DUMMY),
                 PtMemMapped("P8ZP_SCRATCH_W2", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W2, null, Position.DUMMY),
-                PtMemMapped("P8ESTACK_LO", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_LO, 128u, Position.DUMMY),
-                PtMemMapped("P8ESTACK_HI", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_HI, 128u, Position.DUMMY)
             ).forEach {
                 it.parent = program
                 st.add(StMemVar(it.name, it.type, it.address, it.arraySize?.toInt(), it))

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

@@ -118,6 +118,9 @@ class PtArrayIndexer(elementType: DataType, position: Position): PtExpression(el
     val splitWords: Boolean
         get() = variable.type in SplitWordArrayTypes
 
+    val usesPointerVariable: Boolean
+        get() = variable.type==DataType.UWORD
+
     init {
         require(elementType in NumericDatatypes)
     }

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

@@ -126,7 +126,6 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 else
                     "->"
             }
-            else -> throw InternalCompilerException("unrecognised ast node $node")
         }
     }
 

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

@@ -78,7 +78,9 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "reverse"   to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
     // cmp returns a status in the carry flag, but not a proper return value
     "cmp"       to FSignature(false, listOf(FParam("value1", IntegerDatatypesNoBool), FParam("value2", NumericDatatypesNoBool)), null),
-    "prog8_lib_stringcompare"       to FSignature(true, listOf(FParam("str1", arrayOf(DataType.STR)), FParam("str2", arrayOf(DataType.STR))), DataType.BYTE),
+    "prog8_lib_stringcompare"     to FSignature(true, listOf(FParam("str1", arrayOf(DataType.STR)), FParam("str2", arrayOf(DataType.STR))), DataType.BYTE),
+    "prog8_lib_square_byte"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), DataType.UBYTE),
+    "prog8_lib_square_word"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD, DataType.UWORD))), DataType.UWORD),
     "abs"       to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), null),
     "abs__byte"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE))), DataType.BYTE),
     "abs__word"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD))), DataType.WORD),
@@ -124,9 +126,7 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "push"      to FSignature(false, listOf(FParam("value", ByteDatatypes)), null),
     "pushw"     to FSignature(false, listOf(FParam("value", WordDatatypes)), null),
     "rsave"     to FSignature(false, emptyList(), null),
-    "rsavex"    to FSignature(false, emptyList(), null),
     "rrestore"  to FSignature(false, emptyList(), null),
-    "rrestorex" to FSignature(false, emptyList(), null),
     "memory"    to FSignature(true, listOf(FParam("name", arrayOf(DataType.STR)), FParam("size", arrayOf(DataType.UWORD)), FParam("alignment", arrayOf(DataType.UWORD))), DataType.UWORD),
     "callfar"   to FSignature(false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), DataType.UWORD),
 )

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

@@ -13,15 +13,14 @@ class CompilationOptions(val output: OutputType,
                          val compTarget: ICompilationTarget,
                          // these are set later, based on command line arguments or options in the source code:
                          var loadAddress: UInt,
-                         var slowCodegenWarnings: Boolean = false,
+                         var warnSymbolShadowing: Boolean = false,
                          var optimize: Boolean = false,
-                         var optimizeFloatExpressions: Boolean = false,
                          var asmQuiet: Boolean = false,
                          var asmListfile: Boolean = false,
+                         var includeSourcelines: Boolean = false,
                          var experimentalCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var splitWordArrays: Boolean = false,
-                         var evalStackBaseAddress: UInt? = null,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()
 ) {

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

@@ -13,8 +13,6 @@ interface IMachineDefinition {
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
     val FLOAT_MEM_SIZE: Int
-    var ESTACK_LO: UInt
-    var ESTACK_HI: UInt
     val PROGRAM_LOAD_ADDRESS : UInt
     val BSSHIGHRAM_START: UInt
     val BSSHIGHRAM_END: UInt
@@ -29,11 +27,4 @@ interface IMachineDefinition {
     fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String>
     fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path)
     fun isIOAddress(address: UInt): Boolean
-    fun overrideEvalStack(evalStackBaseAddress: UInt) {
-        require(evalStackBaseAddress and 255u == 0u)
-        ESTACK_LO = evalStackBaseAddress
-        ESTACK_HI = evalStackBaseAddress + 256u
-        require(ESTACK_LO !in golden.region && ESTACK_HI !in golden.region) { "user-set ESTACK can't be in GOLDEN ram" }
-    }
-
 }

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

@@ -1,6 +1,6 @@
 package prog8.code.core
 
-import prog8.code.core.SourceCode.Companion.libraryFilePrefix
+import prog8.code.core.SourceCode.Companion.LIBRARYFILEPREFIX
 import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
 import kotlin.io.path.absolute
@@ -10,7 +10,7 @@ data class Position(val file: String, val line: Int, val startCol: Int, val endC
     fun toClickableStr(): String {
         if(this===DUMMY)
             return ""
-        if(file.startsWith(libraryFilePrefix))
+        if(file.startsWith(LIBRARYFILEPREFIX))
             return "$file:$line:$startCol:"
         return try {
             val path = Path(file).absolute().normalize().toString()

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

@@ -54,12 +54,14 @@ sealed class SourceCode {
         /**
          * filename prefix to designate library files that will be retreived from internal resources rather than disk
          */
-        const val libraryFilePrefix = "library:"
-        const val stringSourcePrefix = "string:"
+        const val LIBRARYFILEPREFIX = "library:"
+        const val STRINGSOURCEPREFIX = "string:"
         val curdir: Path = Path(".").toAbsolutePath()
         fun relative(path: Path): Path = curdir.relativize(path.toAbsolutePath())
         fun isRegularFilesystemPath(pathString: String) =
-            !(pathString.startsWith(libraryFilePrefix) || pathString.startsWith(stringSourcePrefix))
+            !(pathString.startsWith(LIBRARYFILEPREFIX) || pathString.startsWith(STRINGSOURCEPREFIX))
+
+        fun isLibraryResource(path: String) = path.startsWith(LIBRARYFILEPREFIX)
     }
 
     /**
@@ -69,7 +71,7 @@ sealed class SourceCode {
     class Text(override val text: String): SourceCode() {
         override val isFromResources = false
         override val isFromFilesystem = false
-        override val origin = "$stringSourcePrefix${System.identityHashCode(text).toString(16)}"
+        override val origin = "$STRINGSOURCEPREFIX${System.identityHashCode(text).toString(16)}"
         override val name = "<unnamed-text>"
     }
 
@@ -110,7 +112,7 @@ sealed class SourceCode {
 
         override val isFromResources = true
         override val isFromFilesystem = false
-        override val origin = "$libraryFilePrefix$normalized"
+        override val origin = "$LIBRARYFILEPREFIX$normalized"
         override val text: String
         override val name: String
 
@@ -139,3 +141,33 @@ sealed class SourceCode {
         override val text: String = "<generated code node, no text representation>"
     }
 }
+
+
+object SourceLineCache {
+    private val cache = mutableMapOf<String, List<String>>()
+
+    private fun getCachedFile(file: String): List<String> {
+        val existing = cache[file]
+        if(existing!=null)
+            return existing
+        if (SourceCode.isRegularFilesystemPath(file)) {
+            val source = SourceCode.File(Path(file))
+            cache[file] = source.text.split('\n', '\r').map { it.trim() }
+            return cache.getValue(file)
+        } else if(file.startsWith(SourceCode.LIBRARYFILEPREFIX)) {
+            val source = SourceCode.Resource(file.drop(SourceCode.LIBRARYFILEPREFIX.length))
+            cache[file] = source.text.split('\n', '\r').map { it.trim()}
+            return cache.getValue(file)
+        }
+        return emptyList()
+    }
+
+    fun retrieveLine(position: Position): String? {
+        if (position.line>0) {
+            val lines = getCachedFile(position.file)
+            if(lines.isNotEmpty())
+                return lines[position.line-1]
+        }
+        return null
+    }
+}

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

@@ -0,0 +1,20 @@
+package prog8.code.target
+
+import prog8.code.core.Encoding
+import prog8.code.core.ICompilationTarget
+import prog8.code.core.IMemSizer
+import prog8.code.core.IStringEncoding
+import prog8.code.target.cbm.CbmMemorySizer
+import prog8.code.target.pet.PETMachineDefinition
+
+
+class PETTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
+    override val machine = PETMachineDefinition()
+    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
+    override val defaultEncoding = Encoding.PETSCII
+
+    companion object {
+        const val NAME = "pet32"
+    }
+}

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

@@ -13,10 +13,6 @@ class AtariMachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = 6
     override val PROGRAM_LOAD_ADDRESS = 0x2000u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x1b00u     //  $1b00-$1b7f inclusive      // TODO
-    override var ESTACK_HI = 0x1b80u     //  $1b80-$1bff inclusive      // TODO
-
     override val BSSHIGHRAM_START = 0u    // TODO
     override val BSSHIGHRAM_END = 0u      // TODO
 

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

@@ -15,10 +15,6 @@ class C128MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x1c01u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x1b00u     //  $1b00-$1b7f inclusive
-    override var ESTACK_HI = 0x1b80u     //  $1b80-$1bff inclusive
-
     override val BSSHIGHRAM_START = 0u    // TODO
     override val BSSHIGHRAM_END = 0u      // TODO
 

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

@@ -16,12 +16,8 @@ class C64MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0xcf00u     //  $cf00-$cf7f inclusive
-    override var ESTACK_HI = 0xcf80u     //  $cf80-$cfff inclusive
-
     override val BSSHIGHRAM_START = 0xc000u
-    override val BSSHIGHRAM_END = ESTACK_LO
+    override val BSSHIGHRAM_END = 0xd000u
 
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam
@@ -62,7 +58,7 @@ class C64MachineDefinition: IMachineDefinition {
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = C64Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0xc000u until ESTACK_LO)
+        golden = GoldenRam(compilerOptions, 0xc000u until 0xd000u)
     }
 
 }

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

@@ -15,10 +15,6 @@ class CX16MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x0700u        //  $0700-$077f inclusive
-    override var ESTACK_HI = 0x0780u        //  $0780-$07ff inclusive
-
     override val BSSHIGHRAM_START = 0xa000u     // hiram bank 1, 8Kb, assumed to be active
     override val BSSHIGHRAM_END = 0xc000u       // rom starts here.
 
@@ -64,7 +60,7 @@ class CX16MachineDefinition: IMachineDefinition {
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0x0400u until ESTACK_LO)
+        golden = GoldenRam(compilerOptions, 0x0400u until 0x0800u)
     }
 
 }

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

@@ -40,7 +40,6 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
                 ZeropageType.DONTUSE -> {
                     free.clear() // don't use zeropage at all
                 }
-                else -> throw InternalCompilerException("for this machine target, zero page type 'floatsafe' is not available. ${options.zeropage}")
             }
 
             val distinctFree = free.distinct()

codeCore/src/prog8/code/target/pet/PETMachineDefinition.kt

@@ -0,0 +1,55 @@
+package prog8.code.target.pet
+
+import prog8.code.core.*
+import prog8.code.target.C64Target
+import prog8.code.target.cbm.Mflpt5
+import java.nio.file.Path
+
+
+class PETMachineDefinition: IMachineDefinition {
+
+    override val cpu = CpuType.CPU6502
+
+    override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
+    override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
+    override val PROGRAM_LOAD_ADDRESS = 0x0401u
+
+    override val BSSHIGHRAM_START = 0xffffu
+    override val BSSHIGHRAM_END = 0xffffu
+
+    override lateinit var zeropage: Zeropage
+    override lateinit var golden: GoldenRam
+
+    override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
+
+    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
+        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
+            listOf("syslib")
+        else
+            emptyList()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
+        if(selectedEmulator!=1) {
+            System.err.println("The pet target only supports the main emulator (Vice).")
+            return
+        }
+
+        println("\nStarting PET emulator...")
+        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
+        val cmdline = listOf("xpet", "-model", "4032", "-ramsize", "32", "-videosize", "40", "-silent", "-moncommands", viceMonlist,
+                "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+        val processb = ProcessBuilder(cmdline).inheritIO()
+        val process=processb.start()
+        process.waitFor()
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address in 0xe800u..0xe8ffu
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = PETZeropage(compilerOptions)
+        // there's no golden ram.
+    }
+
+}

codeCore/src/prog8/code/target/pet/PETZeropage.kt

@@ -0,0 +1,58 @@
+package prog8.code.target.pet
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.InternalCompilerException
+import prog8.code.core.Zeropage
+import prog8.code.core.ZeropageType
+
+
+// reference: http://www.zimmers.net/cbmpics/cbm/PETx/petmem.txt
+
+class PETZeropage(options: CompilationOptions) : Zeropage(options) {
+
+    override val SCRATCH_B1 = 0xb3u      // temp storage for a single byte
+    override val SCRATCH_REG = 0xb4u     // temp storage for a register, must be B1+1
+    override val SCRATCH_W1 = 0xb6u      // temp storage 1 for a word
+    override val SCRATCH_W2 = 0xb8u      // temp storage 2 for a word
+
+    init {
+        if (options.floats) {
+            throw InternalCompilerException("PET target doesn't yet support floating point routines")
+        }
+
+        if (options.floats && options.zeropage !in arrayOf(
+                ZeropageType.FLOATSAFE,
+                ZeropageType.BASICSAFE,
+                ZeropageType.DONTUSE
+            ))
+            throw InternalCompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe' or 'dontuse'")
+
+        when (options.zeropage) {
+            ZeropageType.FULL -> {
+                free.addAll(0x00u..0xffu)
+                free.removeAll(listOf(0x8du, 0x8eu, 0x8fu, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9eu, 0xa7u, 0xa8u, 0xa9u, 0xaau))        // these are updated/used by IRQ
+            }
+            ZeropageType.KERNALSAFE -> {
+                free.addAll(0x00u..0xffu)
+                free.removeAll(listOf(0x8du, 0x8eu, 0x8fu, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9eu, 0xa7u, 0xa8u, 0xa9u, 0xaau))        // these are updated/used by IRQ
+            }
+            ZeropageType.FLOATSAFE,
+            ZeropageType.BASICSAFE -> {
+                free.addAll(0xb3u..0xbau)       // TODO more?
+            }
+            ZeropageType.DONTUSE -> {
+                free.clear()  // don't use zeropage at all
+            }
+        }
+
+        val distinctFree = free.distinct()
+        free.clear()
+        free.addAll(distinctFree)
+
+        removeReservedFromFreePool()
+    }
+
+    override fun allocateCx16VirtualRegisters() {
+        TODO("Not known if C128 can put the virtual regs in ZP")
+    }
+}

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

@@ -15,8 +15,6 @@ class VirtualMachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = 4             // 32-bits floating point
     override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
 
-    override var ESTACK_LO = 0u                 // not actually used
-    override var ESTACK_HI = 0u                 // not actually used
     override val BSSHIGHRAM_START = 0u          // not actually used
     override val BSSHIGHRAM_END = 0u            // not actually used
     override lateinit var zeropage: Zeropage    // not actually used

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

@@ -172,8 +172,6 @@ private fun PtFunctionCall.prefix(parent: PtNode): PtFunctionCall {
     call.children.addAll(children)
     call.children.forEach { it.parent = call }
     call.parent = parent
-    if(name.endsWith("concat_string"))
-        println("CONCAT ${this.position}")
     return call
 }
 
@@ -203,12 +201,12 @@ class AsmGen6502Internal (
     private val allocator = VariableAllocator(symbolTable, options, errors)
     private val assemblyLines = mutableListOf<String>()
     private val breakpointLabels = mutableListOf<String>()
-    private val forloopsAsmGen = ForLoopsAsmGen(program, this, zeropage)
+    private val forloopsAsmGen = ForLoopsAsmGen(this, zeropage)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
     private val programGen = ProgramAndVarsGen(program, options, errors, symbolTable, functioncallAsmGen, this, allocator, zeropage)
-    private val assignmentAsmGen = AssignmentAsmGen(program, symbolTable, this, allocator)
-    private val expressionsAsmGen = ExpressionsAsmGen(program, this, allocator)
+    private val anyExprGen = AnyExprAsmGen(this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this, anyExprGen, allocator)
     private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen)
 
     fun compileToAssembly(): IAssemblyProgram? {
@@ -240,8 +238,19 @@ class AsmGen6502Internal (
 
     internal fun isTargetCpu(cpu: CpuType) = options.compTarget.machine.cpu == cpu
 
+    private var lastSourceLineNumber: Int = -1
+
     internal fun outputSourceLine(node: PtNode) {
-        out(" ;\tsrc line: ${node.position.file}:${node.position.line}")
+        if(!options.includeSourcelines || node.position===Position.DUMMY || node.position.line==lastSourceLineNumber)
+            return
+
+        lastSourceLineNumber = node.position.line
+        val srcComment = "\t; source: ${node.position.file}:${node.position.line}"
+        val line = SourceLineCache.retrieveLine(node.position)
+        if(line==null)
+            out(srcComment, false)
+        else
+            out("$srcComment   $line", false)
     }
 
     internal fun out(str: String, splitlines: Boolean = true) {
@@ -394,32 +403,6 @@ class AsmGen6502Internal (
         return name2.replace("prog8_lib.P8ZP_SCRATCH_", "P8ZP_SCRATCH_")    // take care of the 'hooks' to the temp vars -> reference zp symbols directly
     }
 
-    internal fun saveRegisterLocal(register: CpuRegister, scope: IPtSubroutine) {
-        if (isTargetCpu(CpuType.CPU65c02)) {
-            // just use the cpu's stack for all registers, shorter code
-            when (register) {
-                CpuRegister.A -> out("  pha")
-                CpuRegister.X -> out("  phx")
-                CpuRegister.Y -> out("  phy")
-            }
-        } else {
-            when (register) {
-                CpuRegister.A -> {
-                    // just use the stack, only for A
-                    out("  pha")
-                }
-                CpuRegister.X -> {
-                    out("  stx  prog8_regsaveX")
-                    subroutineExtra(scope).usedRegsaveX = true
-                }
-                CpuRegister.Y -> {
-                    out("  sty  prog8_regsaveY")
-                    subroutineExtra(scope).usedRegsaveY = true
-                }
-            }
-        }
-    }
-
     internal fun saveRegisterStack(register: CpuRegister, keepA: Boolean) {
         when (register) {
             CpuRegister.A -> out("  pha")
@@ -444,24 +427,6 @@ class AsmGen6502Internal (
         }
     }
 
-    internal fun restoreRegisterLocal(register: CpuRegister) {
-        if (isTargetCpu(CpuType.CPU65c02)) {
-            when (register) {
-                // this just used the stack, for all registers. Shorter code.
-                CpuRegister.A -> out("  pla")
-                CpuRegister.X -> out("  plx")
-                CpuRegister.Y -> out("  ply")
-            }
-
-        } else {
-            when (register) {
-                CpuRegister.A -> out("  pla")   // this just used the stack but only for A
-                CpuRegister.X -> out("  ldx  prog8_regsaveX")
-                CpuRegister.Y -> out("  ldy  prog8_regsaveY")
-            }
-        }
-    }
-
     internal fun restoreRegisterStack(register: CpuRegister, keepA: Boolean) {
         when (register) {
             CpuRegister.A -> {
@@ -581,22 +546,12 @@ class AsmGen6502Internal (
         }
     }
 
-    @Deprecated("avoid calling this as it generates slow evalstack based code")
-    internal fun translateExpression(expression: PtExpression) =
-            expressionsAsmGen.translateExpression(expression)
-
-    internal fun translateBuiltinFunctionCallExpression(bfc: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? =
-            builtinFunctionsAsmGen.translateFunctioncallExpression(bfc, resultToStack, resultRegister)
+    internal fun translateBuiltinFunctionCallExpression(bfc: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?): DataType? =
+            builtinFunctionsAsmGen.translateFunctioncallExpression(bfc, resultRegister)
 
     internal fun translateFunctionCall(functionCallExpr: PtFunctionCall) =
             functioncallAsmGen.translateFunctionCall(functionCallExpr)
 
-    internal fun saveXbeforeCall(functionCall: PtFunctionCall)  =
-            functioncallAsmGen.saveXbeforeCall(functionCall)
-
-    internal fun restoreXafterCall(functionCall: PtFunctionCall) =
-            functioncallAsmGen.restoreXafterCall(functionCall)
-
     internal fun translateNormalAssignment(assign: AsmAssignment, scope: IPtSubroutine?) =
             assignmentAsmGen.translateNormalAssignment(assign, scope)
 
@@ -625,7 +580,6 @@ class AsmGen6502Internal (
     }
 
     internal fun assignExpressionTo(value: PtExpression, target: AsmAssignTarget) {
-        // don't use translateExpression() to avoid evalstack
         when (target.datatype) {
             in ByteDatatypes -> {
                 assignExpressionToRegister(value, RegisterOrPair.A)
@@ -907,7 +861,7 @@ $repeatLabel""")
             DataType.UBYTE, DataType.UWORD -> {
                 val result = zeropage.allocate(counterVar, dt, null, stmt.position, errors)
                 result.fold(
-                    success = { (address, _) -> asmInfo.extraVars.add(Triple(dt, counterVar, address)) },
+                    success = { (address, _, _) -> asmInfo.extraVars.add(Triple(dt, counterVar, address)) },
                     failure = { asmInfo.extraVars.add(Triple(dt, counterVar, null)) }  // allocate normally
                 )
                 return counterVar
@@ -1047,7 +1001,10 @@ $repeatLabel""")
     }
 
     private fun translate(asm: PtInlineAssembly) {
-        assemblyLines.add(asm.assembly.trimEnd().trimStart('\r', '\n'))
+        if(asm.isIR)
+            throw AssemblyError("%asm containing IR code cannot be translated to 6502 assembly")
+        else
+            assemblyLines.add(asm.assembly.trimEnd().trimStart('\r', '\n'))
     }
 
     private fun translate(incbin: PtIncludeBinary) {
@@ -1086,20 +1043,6 @@ $repeatLabel""")
         }
     }
 
-    internal fun signExtendStackLsb(valueDt: DataType) {
-        // sign extend signed byte on stack to signed word on stack
-        when(valueDt) {
-            DataType.UBYTE -> {
-                if(isTargetCpu(CpuType.CPU65c02))
-                    out("  stz  P8ESTACK_HI+1,x")
-                else
-                    out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
-            }
-            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_stack_byte")
-            else -> throw AssemblyError("need byte type")
-        }
-    }
-
     internal fun signExtendVariableLsb(asmvar: String, valueDt: DataType) {
         // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
@@ -1728,7 +1671,7 @@ $repeatLabel""")
                 }
                 else if (left is PtMemoryByte) {
                     return if(rightConstVal.number.toInt()!=0) {
-                        translateDirectMemReadExpressionToRegAorStack(left, false)
+                        translateDirectMemReadExpressionToRegA(left)
                         code("#${rightConstVal.number.toInt()}")
                     }
                     else
@@ -1875,7 +1818,7 @@ $repeatLabel""")
                         out("  beq $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2036,7 +1979,7 @@ $repeatLabel""")
                         out("  bne  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2200,7 +2143,7 @@ $repeatLabel""")
                 }
                 else if (left is PtMemoryByte) {
                     if(rightConstVal.number.toInt()!=0) {
-                        translateDirectMemReadExpressionToRegAorStack(left, false)
+                        translateDirectMemReadExpressionToRegA(left)
                         code("#${rightConstVal.number.toInt()}")
                     }
                     return
@@ -2363,7 +2306,7 @@ $repeatLabel""")
                         out("  bne  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2409,7 +2352,7 @@ $repeatLabel""")
                         out("  beq  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2865,22 +2808,14 @@ $repeatLabel""")
 +""")
     }
 
-    internal fun translateDirectMemReadExpressionToRegAorStack(expr: PtMemoryByte, pushResultOnEstack: Boolean) {
+    internal fun translateDirectMemReadExpressionToRegA(expr: PtMemoryByte) {
 
         fun assignViaExprEval() {
             assignExpressionToVariable(expr.address, "P8ZP_SCRATCH_W2", DataType.UWORD)
             if (isTargetCpu(CpuType.CPU65c02)) {
-                if (pushResultOnEstack) {
-                    out("  lda  (P8ZP_SCRATCH_W2) |  dex |  sta  P8ESTACK_LO+1,x")
-                } else {
-                    out("  lda  (P8ZP_SCRATCH_W2)")
-                }
+                out("  lda  (P8ZP_SCRATCH_W2)")
             } else {
-                if (pushResultOnEstack) {
-                    out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y |  dex |  sta  P8ESTACK_LO+1,x")
-                } else {
-                    out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
-                }
+                out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
             }
         }
 
@@ -2888,21 +2823,14 @@ $repeatLabel""")
             is PtNumber -> {
                 val address = (expr.address as PtNumber).number.toInt()
                 out("  lda  ${address.toHex()}")
-                if(pushResultOnEstack)
-                    out("  sta  P8ESTACK_LO,x |  dex")
             }
             is PtIdentifier -> {
                 // the identifier is a pointer variable, so read the value from the address in it
                 loadByteFromPointerIntoA(expr.address as PtIdentifier)
-                if(pushResultOnEstack)
-                    out("  sta  P8ESTACK_LO,x |  dex")
             }
             is PtBinaryExpression -> {
                 val addrExpr = expr.address as PtBinaryExpression
-                if(tryOptimizedPointerAccessWithA(addrExpr, addrExpr.operator, false)) {
-                    if(pushResultOnEstack)
-                        out("  sta  P8ESTACK_LO,x |  dex")
-                } else {
+                if(!tryOptimizedPointerAccessWithA(addrExpr, addrExpr.operator, false)) {
                     assignViaExprEval()
                 }
             }
@@ -3098,6 +3026,14 @@ $repeatLabel""")
         }
     }
 
+    internal fun pushFAC1() {
+        out("  jsr  floats.pushFAC1")
+    }
+
+    internal fun popFAC1() {
+        out("  jsr  floats.popFAC1")
+    }
+
     internal fun needAsaveForExpr(arg: PtExpression): Boolean =
         arg !is PtNumber && arg !is PtIdentifier && (arg !is PtMemoryByte || !arg.isSimple())
 
@@ -3130,9 +3066,6 @@ $repeatLabel""")
  * it's more consistent to only define these attributes on a Subroutine node.
  */
 internal class SubroutineExtraAsmInfo {
-    var usedRegsaveA = false
-    var usedRegsaveX = false
-    var usedRegsaveY = false
     var usedFloatEvalResultVar1 = false
     var usedFloatEvalResultVar2 = false
 

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

@@ -15,21 +15,7 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
 
     var linesByFour = getLinesBy(lines, 4)
 
-    var mods = optimizeUselessStackByteWrites(linesByFour)
-    if(mods.isNotEmpty()) {
-        apply(mods, lines)
-        linesByFour = getLinesBy(lines, 4)
-        numberOfOptimizations++
-    }
-
-    mods = optimizeIncDec(linesByFour)
-    if(mods.isNotEmpty()) {
-        apply(mods, lines)
-        linesByFour = getLinesBy(lines, 4)
-        numberOfOptimizations++
-    }
-
-    mods = optimizeCmpSequence(linesByFour)
+    var mods = optimizeIncDec(linesByFour)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
@@ -97,44 +83,6 @@ private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
 // all lines (that aren't empty or comments) in sliding windows of certain size
         lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
 
-private fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // when statement (on bytes) generates a sequence of:
-    //	 lda  $ce01,x
-    //	 cmp  #$20
-    //	 beq  check_prog8_s72choice_32
-    //	 lda  $ce01,x
-    //	 cmp  #$21
-    //	 beq  check_prog8_s73choice_33
-    // the repeated lda can be removed
-    val mods = mutableListOf<Modification>()
-    for(lines in linesByFour) {
-        if(lines[0].value.trim()=="lda  P8ESTACK_LO+1,x" &&
-                lines[1].value.trim().startsWith("cmp ") &&
-                lines[2].value.trim().startsWith("beq ") &&
-                lines[3].value.trim()=="lda  P8ESTACK_LO+1,x") {
-            mods.add(Modification(lines[3].index, true, null)) // remove the second lda
-        }
-    }
-    return mods
-}
-
-private fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // sta on stack, dex, inx, lda from stack -> eliminate this useless stack byte write
-    // this is a lot harder for word values because the instruction sequence varies.
-    val mods = mutableListOf<Modification>()
-    for(lines in linesByFour) {
-        if(lines[0].value.trim()=="sta  P8ESTACK_LO,x" &&
-                lines[1].value.trim()=="dex" &&
-                lines[2].value.trim()=="inx" &&
-                lines[3].value.trim()=="lda  P8ESTACK_LO,x") {
-            mods.add(Modification(lines[1].index, true, null))
-            mods.add(Modification(lines[2].index, true, null))
-            mods.add(Modification(lines[3].index, true, null))
-        }
-    }
-    return mods
-}
-
 private fun optimizeSameAssignments(
     linesByFourteen: List<List<IndexedValue<String>>>,
     machine: IMachineDefinition,

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

@@ -1,14 +1,8 @@
 package prog8.codegen.cpu6502
 
-import com.github.michaelbull.result.Ok
-import com.github.michaelbull.result.Result
-import com.github.michaelbull.result.mapError
 import prog8.code.core.*
 import prog8.code.target.C64Target
-import java.io.File
 import java.nio.file.Path
-import kotlin.io.path.Path
-import kotlin.io.path.isRegularFile
 
 
 internal class AssemblyProgram(
@@ -28,15 +22,20 @@ internal class AssemblyProgram(
         val assemblerCommand: List<String>
 
         when (compTarget.name) {
-            in setOf("c64", "c128", "cx16") -> {
+            in setOf("c64", "c128", "cx16", "pet32") -> {
                 // CBM machines .prg generation.
 
                 // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps (default = do this silently)
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
+                    "-Wall", // "-Wno-strict-bool", "-Werror",
                     "--dump-labels", "--vice-labels", "--labels=$viceMonListFile", "--no-monitor"
                 )
 
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
                 if(options.asmQuiet)
                     command.add("--quiet")
 
@@ -65,10 +64,15 @@ internal class AssemblyProgram(
 
                 // TODO are these options okay for atari?
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
+                    "-Wall", // "-Werror", "-Wno-strict-bool"
                     "--no-monitor"
                 )
 
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
                 if(options.asmQuiet)
                     command.add("--quiet")
 
@@ -130,18 +134,3 @@ internal class AssemblyProgram(
         viceMonListFile.toFile().appendText(breakpoints.joinToString("\n") + "\n")
     }
 }
-
-
-internal fun loadAsmIncludeFile(filename: String, source: SourceCode): Result<String, NoSuchFileException> {
-    return if (filename.startsWith(SourceCode.libraryFilePrefix)) {
-        return com.github.michaelbull.result.runCatching {
-            SourceCode.Resource("/prog8lib/${filename.substring(SourceCode.libraryFilePrefix.length)}").text
-        }.mapError { NoSuchFileException(File(filename)) }
-    } else {
-        val sib = Path(source.origin).resolveSibling(filename)
-        if (sib.isRegularFile())
-            Ok(SourceCode.File(sib).text)
-        else
-            Ok(SourceCode.File(Path(filename)).text)
-    }
-}

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

@@ -10,34 +10,31 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                                       private val asmgen: AsmGen6502Internal,
                                       private val assignAsmGen: AssignmentAsmGen) {
 
-    internal fun translateFunctioncallExpression(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? {
-        return translateFunctioncall(fcall, discardResult = false, resultToStack = resultToStack, resultRegister = resultRegister)
+    internal fun translateFunctioncallExpression(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?): DataType? {
+        return translateFunctioncall(fcall, discardResult = false, resultRegister = resultRegister)
     }
 
     internal fun translateFunctioncallStatement(fcall: PtBuiltinFunctionCall) {
-        translateFunctioncall(fcall, discardResult = true, resultToStack = false, resultRegister = null)
+        translateFunctioncall(fcall, discardResult = true, resultRegister = null)
     }
 
-    private fun translateFunctioncall(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? {
+    private fun translateFunctioncall(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultRegister: RegisterOrPair?): DataType? {
         if (discardResult && fcall.hasNoSideEffects)
             return null  // can just ignore the whole function call altogether
 
-        if(discardResult && resultToStack)
-            throw AssemblyError("cannot both discard the result AND put it onto stack")
-
         val sscope = fcall.definingISub()
 
         when (fcall.name) {
-            "msb" -> funcMsb(fcall, resultToStack, resultRegister)
-            "lsb" -> funcLsb(fcall, resultToStack, resultRegister)
-            "mkword" -> funcMkword(fcall, resultToStack, resultRegister)
-            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(fcall, resultToStack, resultRegister)
-            "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(fcall, resultToStack, resultRegister)
-            "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(fcall, resultToStack, resultRegister)
-            "abs__byte", "abs__word", "abs__float" -> funcAbs(fcall, resultToStack, resultRegister, sscope)
-            "any", "all" -> funcAnyAll(fcall, resultToStack, resultRegister, sscope)
-            "sgn" -> funcSgn(fcall, resultToStack, resultRegister, sscope)
-            "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(fcall, resultToStack, resultRegister, sscope)
+            "msb" -> funcMsb(fcall, resultRegister)
+            "lsb" -> funcLsb(fcall, resultRegister)
+            "mkword" -> funcMkword(fcall, resultRegister)
+            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(fcall, resultRegister)
+            "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(fcall, resultRegister)
+            "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(fcall, resultRegister)
+            "abs__byte", "abs__word", "abs__float" -> funcAbs(fcall, resultRegister, sscope)
+            "any", "all" -> funcAnyAll(fcall, resultRegister, sscope)
+            "sgn" -> funcSgn(fcall, resultRegister, sscope)
+            "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(fcall, resultRegister, sscope)
             "divmod__ubyte" -> funcDivmod(fcall)
             "divmod__uword" -> funcDivmodW(fcall)
             "rol" -> funcRol(fcall)
@@ -46,8 +43,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "ror2" -> funcRor2(fcall)
             "sort" -> funcSort(fcall)
             "reverse" -> funcReverse(fcall)
-            "memory" -> funcMemory(fcall, discardResult, resultToStack, resultRegister)
-            "peekw" -> funcPeekW(fcall, resultToStack, resultRegister)
+            "memory" -> funcMemory(fcall, discardResult, resultRegister)
+            "peekw" -> funcPeekW(fcall, resultRegister)
             "peek" -> throw AssemblyError("peek() should have been replaced by @()")
             "pokew" -> funcPokeW(fcall)
             "pokemon" -> { /* meme function */ }
@@ -71,18 +68,35 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 asmgen.popCpuStack(DataType.UWORD, target, fcall.definingISub())
             }
             "rsave" -> funcRsave()
-            "rsavex" -> funcRsaveX()
             "rrestore" -> funcRrestore()
-            "rrestorex" -> funcRrestoreX()
             "cmp" -> funcCmp(fcall)
             "callfar" -> funcCallFar(fcall)
-            "prog8_lib_stringcompare" -> funcStringCompare(fcall, resultToStack)
+            "prog8_lib_stringcompare" -> funcStringCompare(fcall)
+            "prog8_lib_square_byte" -> funcSquare(fcall, DataType.UBYTE)
+            "prog8_lib_square_word" -> funcSquare(fcall, DataType.UWORD)
             else -> throw AssemblyError("missing asmgen for builtin func ${fcall.name}")
         }
 
         return BuiltinFunctions.getValue(fcall.name).returnType
     }
 
+    private fun funcSquare(fcall: PtBuiltinFunctionCall, resultType: DataType) {
+        // square of word value is faster with dedicated routine, square of byte just use the regular multiplication routine.
+        when (resultType) {
+            DataType.UBYTE -> {
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)
+                asmgen.out("  tay  |  jsr  math.multiply_bytes")
+            }
+            DataType.UWORD -> {
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+                asmgen.out("  jsr  math.square")
+            }
+            else -> {
+                throw AssemblyError("optimized square only for integer types")
+            }
+        }
+    }
+
     private fun funcDivmod(fcall: PtBuiltinFunctionCall) {
         assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A, false)
         asmgen.saveRegisterStack(CpuRegister.A, false)
@@ -115,11 +129,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             sty  $remainderVar+1""")
     }
 
-    private fun funcStringCompare(fcall: PtBuiltinFunctionCall, resultToStack: Boolean) {
+    private fun funcStringCompare(fcall: PtBuiltinFunctionCall) {
         asmgen.assignWordOperandsToAYAndVar(fcall.args[0], fcall.args[1], "P8ZP_SCRATCH_W2")
         asmgen.out("  jsr  prog8_lib.strcmp_mem")
-        if(resultToStack)
-            asmgen.out("  sta  P8ESTACK_LO,x |  dex")
     }
 
     private fun funcRsave() {
@@ -142,13 +154,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 lda  P8ZP_SCRATCH_REG""")
     }
 
-    private fun funcRsaveX() {
-        if (asmgen.isTargetCpu(CpuType.CPU65c02))
-            asmgen.out("  phx")
-        else
-            asmgen.out("  txa |  pha")
-    }
-
     private fun funcRrestore() {
         if (asmgen.isTargetCpu(CpuType.CPU65c02))
             asmgen.out("""
@@ -166,13 +171,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 plp""")
     }
 
-    private fun funcRrestoreX() {
-        if (asmgen.isTargetCpu(CpuType.CPU65c02))
-            asmgen.out("  plx")
-        else
-            asmgen.out("  sta  P8ZP_SCRATCH_B1 |  pla |  tax |  lda  P8ZP_SCRATCH_B1")
-    }
-
     private fun funcCallFar(fcall: PtBuiltinFunctionCall) {
         if(asmgen.options.compTarget.name != "cx16")
             throw AssemblyError("callfar only works on cx16 target at this time")
@@ -253,7 +251,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         }
     }
 
-    private fun funcMemory(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMemory(fcall: PtBuiltinFunctionCall, discardResult: Boolean, resultRegister: RegisterOrPair?) {
         if(discardResult)
             throw AssemblyError("should not discard result of memory allocation at $fcall")
         val name = (fcall.args[0] as PtString).value
@@ -263,41 +261,25 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         addressOf.add(slabname)
         addressOf.parent = fcall
         val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UWORD, expression = addressOf)
-        val target =
-            if(resultToStack)
-                AsmAssignTarget(TargetStorageKind.STACK,  asmgen, DataType.UWORD, null, fcall.position)
-            else
-                AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, null, asmgen)
+        val target = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, null, asmgen)
         val assign = AsmAssignment(src, target, program.memsizer, fcall.position)
         asmgen.translateNormalAssignment(assign, fcall.definingISub())
     }
 
-    private fun funcSqrt(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+    private fun funcSqrt(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
         when(fcall.args[0].type) {
             DataType.UBYTE -> {
-                if(resultToStack)
-                    asmgen.out("  ldy  #0 |  jsr  prog8_lib.func_sqrt16_stack")
-                else {
-                    asmgen.out("  ldy  #0 |  jsr  prog8_lib.func_sqrt16_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
-                }
+                asmgen.out("  ldy  #0 |  jsr  prog8_lib.func_sqrt16_into_A")
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
             }
             DataType.UWORD -> {
-                if(resultToStack)
-                    asmgen.out("  jsr  prog8_lib.func_sqrt16_stack")
-                else {
-                    asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
-                }
+                asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
             }
             DataType.FLOAT -> {
                 asmgen.out("  jsr  floats.func_sqrt_into_FAC1")
-                if(resultToStack)
-                    assignAsmGen.assignFAC1float(AsmAssignTarget(TargetStorageKind.STACK, asmgen, DataType.FLOAT, scope, fcall.position))
-                else {
-                    assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
-                }
+                assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
             }
             else -> throw AssemblyError("weird dt")
         }
@@ -466,16 +448,13 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         } else {
                             val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.address)
                             if(ptrAndIndex!=null) {
-                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
-                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
-                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
+                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.A)
+                                asmgen.saveRegisterStack(CpuRegister.A, true)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
-                                asmgen.restoreRegisterLocal(CpuRegister.X)
+                                asmgen.out("  sta  (+) + 1 |  sty  (+) + 2")
+                                asmgen.restoreRegisterStack(CpuRegister.X, false)
                                 asmgen.out("""
-                                    sta  (+) + 1
-                                    sty  (+) + 2
 +                                   ror  ${'$'}ffff,x           ; modified""")
-                                asmgen.restoreRegisterLocal(CpuRegister.X)
                             } else {
                                 asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                                 asmgen.out("""
@@ -571,16 +550,13 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         } else {
                             val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.address)
                             if(ptrAndIndex!=null) {
-                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
-                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
-                                asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
+                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.A)
+                                asmgen.saveRegisterStack(CpuRegister.A, true)
                                 asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
-                                asmgen.restoreRegisterLocal(CpuRegister.X)
+                                asmgen.out("  sta  (+) + 1 |  sty  (+) + 2")
+                                asmgen.restoreRegisterStack(CpuRegister.X, false)
                                 asmgen.out("""
-                                    sta  (+) + 1
-                                    sty  (+) + 2
 +                                   rol  ${'$'}ffff,x           ; modified""")
-                                asmgen.restoreRegisterLocal(CpuRegister.X)
                             } else {
                                 asmgen.assignExpressionToRegister(what.address, RegisterOrPair.AY)
                                 asmgen.out("""
@@ -633,88 +609,56 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.assignExpressionToVariable(indexer.index, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE)
     }
 
-    private fun funcSgn(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+    private fun funcSgn(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
         val dt = fcall.args.single().type
-        if(resultToStack) {
-            when (dt) {
-                DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_stack")
-                DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_stack")
-                DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_stack")
-                DataType.WORD -> asmgen.out("  jsr  prog8_lib.func_sign_w_stack")
-                DataType.FLOAT -> asmgen.out("  jsr  floats.func_sign_f_stack")
-                else -> throw AssemblyError("weird type $dt")
-            }
-        } else {
-            when (dt) {
-                DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_into_A")
-                DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_into_A")
-                DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_into_A")
-                DataType.WORD -> asmgen.out("  jsr  prog8_lib.func_sign_w_into_A")
-                DataType.FLOAT -> asmgen.out("  jsr  floats.func_sign_f_into_A")
-                else -> throw AssemblyError("weird type $dt")
-            }
-            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, true)
+        when (dt) {
+            DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_into_A")
+            DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_into_A")
+            DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_into_A")
+            DataType.WORD -> asmgen.out("  jsr  prog8_lib.func_sign_w_into_A")
+            DataType.FLOAT -> asmgen.out("  jsr  floats.func_sign_f_into_A")
+            else -> throw AssemblyError("weird type $dt")
         }
+        assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, true)
     }
 
-    private fun funcAnyAll(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+    private fun funcAnyAll(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         outputAddressAndLenghtOfArray(fcall.args[0])
         val dt = fcall.args.single().type
-        if(resultToStack) {
-            when (dt) {
-                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_stack")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_stack")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_stack")
-                in SplitWordArrayTypes -> TODO("split word any/all")
-                else -> throw AssemblyError("weird type $dt")
-            }
-        } else {
-            when (dt) {
-                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A |  ldy  #0")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_into_A |  ldy  #0")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_into_A |  ldy  #0")
-                in SplitWordArrayTypes -> TODO("split word any/all")
-                else -> throw AssemblyError("weird type $dt")
-            }
-            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, dt in SignedDatatypes)
+        when (dt) {
+            DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A |  ldy  #0")
+            DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_into_A |  ldy  #0")
+            DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_into_A |  ldy  #0")
+            in SplitWordArrayTypes -> TODO("split word any/all")
+            else -> throw AssemblyError("weird type $dt")
         }
+        assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, dt in SignedDatatypes)
     }
 
-    private fun funcAbs(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
+    private fun funcAbs(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
         val dt = fcall.args.single().type
-        if(resultToStack) {
-            when (dt) {
-                DataType.BYTE -> asmgen.out("  jsr  prog8_lib.abs_b_stack")
-                DataType.WORD -> asmgen.out("  jsr  prog8_lib.abs_w_stack")
-                else -> {
-                    asmgen.out("  jsr  floats.func_abs_f_into_FAC1")
-                    assignAsmGen.assignFAC1float(AsmAssignTarget(TargetStorageKind.STACK, asmgen, DataType.FLOAT, scope, fcall.position))
-                }
+        when (dt) {
+            DataType.BYTE -> {
+                asmgen.out("  jsr  prog8_lib.abs_b_into_A")
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A,false)
             }
-        } else {
-            when (dt) {
-                DataType.BYTE -> {
-                    asmgen.out("  jsr  prog8_lib.abs_b_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A,false)
-                }
-                DataType.WORD -> {
-                    asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, scope, asmgen), RegisterOrPair.AY)
-                }
-                DataType.FLOAT -> {
-                    asmgen.out("  jsr  floats.func_abs_f_into_FAC1")
-                    assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
-                }
-                DataType.UBYTE -> {
-                    asmgen.assignRegister(RegisterOrPair.A, AsmAssignTarget.fromRegisters(resultRegister?:RegisterOrPair.A, false, fcall.position, scope, asmgen))
-                }
-                DataType.UWORD -> {
-                    asmgen.assignRegister(RegisterOrPair.AY, AsmAssignTarget.fromRegisters(resultRegister?:RegisterOrPair.AY, false, fcall.position, scope, asmgen))
-                }
-                else -> throw AssemblyError("weird type")
+            DataType.WORD -> {
+                asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
+                assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, scope, asmgen), RegisterOrPair.AY)
             }
+            DataType.FLOAT -> {
+                asmgen.out("  jsr  floats.func_abs_f_into_FAC1")
+                assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, fcall.position, scope, asmgen))
+            }
+            DataType.UBYTE -> {
+                asmgen.assignRegister(RegisterOrPair.A, AsmAssignTarget.fromRegisters(resultRegister?:RegisterOrPair.A, false, fcall.position, scope, asmgen))
+            }
+            DataType.UWORD -> {
+                asmgen.assignRegister(RegisterOrPair.AY, AsmAssignTarget.fromRegisters(resultRegister?:RegisterOrPair.AY, false, fcall.position, scope, asmgen))
+            }
+            else -> throw AssemblyError("weird type")
         }
     }
 
@@ -730,7 +674,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 val varname = asmgen.asmVariableName(addrExpr)
                 if(asmgen.isZpVar(addrExpr)) {
                     // pointervar is already in the zero page, no need to copy
-                    asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
                     asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
                     if (asmgen.isTargetCpu(CpuType.CPU65c02)) {
                         asmgen.out("""
@@ -746,7 +689,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             iny
                             sta  ($varname),y""")
                     }
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
                     return
                 }
             }
@@ -756,18 +698,15 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 if(result!=null && pointer!=null && asmgen.isZpVar(pointer)) {
                     // can do ZP,Y indexing
                     val varname = asmgen.asmVariableName(pointer)
-                    val scope = fcall.definingISub()!!
-                    asmgen.saveRegisterLocal(CpuRegister.X, scope)
                     asmgen.assignExpressionToRegister(result.second, RegisterOrPair.Y)
-                    asmgen.saveRegisterLocal(CpuRegister.Y, scope)
+                    asmgen.saveRegisterStack(CpuRegister.Y, false)
                     asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
-                    asmgen.restoreRegisterLocal(CpuRegister.Y)
+                    asmgen.restoreRegisterStack(CpuRegister.Y, true)
                     asmgen.out("""
                             sta  ($varname),y
                             txa
                             iny
                             sta  ($varname),y""")
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
                     return
                 }
             }
@@ -779,7 +718,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.out("  jsr  prog8_lib.func_pokew")
     }
 
-    private fun funcPeekW(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcPeekW(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         fun fallback() {
             asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
             asmgen.out("  jsr  prog8_lib.func_peekw")
@@ -830,23 +769,19 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             else -> fallback()
         }
 
-        if(resultToStack){
-            asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-        } else {
-            when(resultRegister ?: RegisterOrPair.AY) {
-                RegisterOrPair.AY -> {}
-                RegisterOrPair.AX -> asmgen.out("  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG")
-                RegisterOrPair.XY -> asmgen.out("  tax")
-                in Cx16VirtualRegisters -> asmgen.out(
-                    "  sta  cx16.${
-                        resultRegister.toString().lowercase()
-                    } |  sty  cx16.${resultRegister.toString().lowercase()}+1")
-                else -> throw AssemblyError("invalid reg")
-            }
+        when(resultRegister ?: RegisterOrPair.AY) {
+            RegisterOrPair.AY -> {}
+            RegisterOrPair.AX -> asmgen.out("  sty  P8ZP_SCRATCH_REG |  ldx  P8ZP_SCRATCH_REG")
+            RegisterOrPair.XY -> asmgen.out("  tax")
+            in Cx16VirtualRegisters -> asmgen.out(
+                "  sta  cx16.${
+                    resultRegister.toString().lowercase()
+                } |  sty  cx16.${resultRegister.toString().lowercase()}+1")
+            else -> throw AssemblyError("invalid reg")
         }
     }
 
-    private fun funcClamp(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcClamp(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type in SignedDatatypes
         when(fcall.type) {
             in ByteDatatypes -> {
@@ -854,30 +789,22 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 assignAsmGen.assignExpressionToVariable(fcall.args[2], "P8ZP_SCRATCH_W1+1", fcall.args[2].type)  // maximum
                 assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A, signed)    // value
                 asmgen.out("  jsr  prog8_lib.func_clamp_${fcall.type.toString().lowercase()}")
-                if(resultToStack) {
-                    asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-                } else {
-                    val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-                    assignAsmGen.assignRegisterByte(targetReg, CpuRegister.A, signed)
-                }
+                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
+                assignAsmGen.assignRegisterByte(targetReg, CpuRegister.A, signed)
             }
             in WordDatatypes -> {
                 assignAsmGen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W1", fcall.args[1].type)  // minimum
                 assignAsmGen.assignExpressionToVariable(fcall.args[2], "P8ZP_SCRATCH_W2", fcall.args[2].type)  // maximum
                 assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY, signed)    // value
                 asmgen.out("  jsr  prog8_lib.func_clamp_${fcall.type.toString().lowercase()}")
-                if(resultToStack) {
-                    asmgen.out("  sta  P8ESTACK_LO,x |  sty  P8ESTACK_HI,x |  dex")
-                } else {
-                    val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
-                    assignAsmGen.assignRegisterpairWord(targetReg, RegisterOrPair.AY)
-                }
+                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
+                assignAsmGen.assignRegisterpairWord(targetReg, RegisterOrPair.AY)
             }
             else -> throw AssemblyError("invalid dt")
         }
     }
 
-    private fun funcMin(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMin(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type in SignedDatatypes
         if(fcall.type in ByteDatatypes) {
             asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_B1", fcall.type)     // right
@@ -887,12 +814,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             asmgen.out("""
                 lda  P8ZP_SCRATCH_B1
 +""")
-            if(resultToStack) {
-                asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-                asmgen.assignRegister(RegisterOrPair.A, targetReg)
-            }
+            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
+            asmgen.assignRegister(RegisterOrPair.A, targetReg)
         } else if(fcall.type in WordDatatypes) {
             asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
             asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
@@ -928,18 +851,14 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     ldy  P8ZP_SCRATCH_W1+1
 +""")
             }
-            if(resultToStack) {
-                asmgen.out("  sta  P8ESTACK_LO,x |  sty  P8ESTACK_HI,x |  dex")
-            } else {
-                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
-                asmgen.assignRegister(RegisterOrPair.AY, targetReg)
-            }
+            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
+            asmgen.assignRegister(RegisterOrPair.AY, targetReg)
         } else {
             throw AssemblyError("min float not supported")
         }
     }
 
-    private fun funcMax(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMax(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type in SignedDatatypes
         if(fcall.type in ByteDatatypes) {
             asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_B1", fcall.type)     // left
@@ -949,12 +868,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             asmgen.out("""
                 lda  P8ZP_SCRATCH_B1
 +""")
-            if(resultToStack) {
-                asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-                asmgen.assignRegister(RegisterOrPair.A, targetReg)
-            }
+            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
+            asmgen.assignRegister(RegisterOrPair.A, targetReg)
         } else if(fcall.type in WordDatatypes) {
             asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
             asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
@@ -990,72 +905,61 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     ldy  P8ZP_SCRATCH_W2+1
 +""")
             }
-            if(resultToStack) {
-                asmgen.out("  sta  P8ESTACK_LO,x |  sty  P8ESTACK_HI,x |  dex")
-            } else {
-                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
-                asmgen.assignRegister(RegisterOrPair.AY, targetReg)
-            }
+            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
+            asmgen.assignRegister(RegisterOrPair.AY, targetReg)
         } else {
             throw AssemblyError("max float not supported")
         }
     }
 
-    private fun funcMkword(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
-        if(resultToStack) {
-            asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)      // msb
-            asmgen.out("  pha")
-            asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-            asmgen.out("  sta  P8ESTACK_LO,x |  pla |  sta  P8ESTACK_HI,x |  dex")
-        } else {
-            val reg = resultRegister ?: RegisterOrPair.AY
-            var needAsave = asmgen.needAsaveForExpr(fcall.args[0])
-            if(!needAsave) {
-                val mr0 = fcall.args[0] as? PtMemoryByte
-                val mr1 = fcall.args[1] as? PtMemoryByte
-                if (mr0 != null)
-                    needAsave =  mr0.address !is PtNumber
-                if (mr1 != null)
-                    needAsave = needAsave or (mr1.address !is PtNumber)
+    private fun funcMkword(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        val reg = resultRegister ?: RegisterOrPair.AY
+        var needAsave = asmgen.needAsaveForExpr(fcall.args[0])
+        if(!needAsave) {
+            val mr0 = fcall.args[0] as? PtMemoryByte
+            val mr1 = fcall.args[1] as? PtMemoryByte
+            if (mr0 != null)
+                needAsave =  mr0.address !is PtNumber
+            if (mr1 != null)
+                needAsave = needAsave or (mr1.address !is PtNumber)
+        }
+        when(reg) {
+            RegisterOrPair.AX -> {
+                asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
+                if(needAsave)
+                    asmgen.out("  pha")
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.X)      // msb
+                if(needAsave)
+                    asmgen.out("  pla")
             }
-            when(reg) {
-                RegisterOrPair.AX -> {
-                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-                    if(needAsave)
-                        asmgen.out("  pha")
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.X)      // msb
-                    if(needAsave)
-                        asmgen.out("  pla")
-                }
-                RegisterOrPair.AY -> {
-                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-                    if(needAsave)
-                        asmgen.out("  pha")
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
-                    if(needAsave)
-                        asmgen.out("  pla")
-                }
-                RegisterOrPair.XY -> {
-                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-                    if(needAsave)
-                        asmgen.out("  pha")
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
-                    if(needAsave)
-                        asmgen.out("  pla")
-                    asmgen.out("  tax")
-                }
-                in Cx16VirtualRegisters -> {
-                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-                    asmgen.out("  sta  cx16.${reg.toString().lowercase()}")
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)      // msb
-                    asmgen.out("  sta  cx16.${reg.toString().lowercase()}+1")
-                }
-                else -> throw AssemblyError("invalid mkword target reg")
+            RegisterOrPair.AY -> {
+                asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
+                if(needAsave)
+                    asmgen.out("  pha")
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
+                if(needAsave)
+                    asmgen.out("  pla")
             }
+            RegisterOrPair.XY -> {
+                asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
+                if(needAsave)
+                    asmgen.out("  pha")
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
+                if(needAsave)
+                    asmgen.out("  pla")
+                asmgen.out("  tax")
+            }
+            in Cx16VirtualRegisters -> {
+                asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
+                asmgen.out("  sta  cx16.${reg.toString().lowercase()}")
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)      // msb
+                asmgen.out("  sta  cx16.${reg.toString().lowercase()}+1")
+            }
+            else -> throw AssemblyError("invalid mkword target reg")
         }
     }
 
-    private fun funcMsb(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcMsb(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val arg = fcall.args.single()
         if (arg.type !in WordDatatypes)
             throw AssemblyError("msb required word argument")
@@ -1063,53 +967,44 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             throw AssemblyError("msb(const) should have been const-folded away")
         if (arg is PtIdentifier) {
             val sourceName = asmgen.asmVariableName(arg)
-            if(resultToStack) {
-                asmgen.out("  lda  $sourceName+1 |  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                when(resultRegister) {
-                    null, RegisterOrPair.A -> asmgen.out("  lda  $sourceName+1")
-                    RegisterOrPair.X -> asmgen.out("  ldx  $sourceName+1")
-                    RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName+1")
-                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName+1 |  ldx  #0")
-                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName+1 |  ldy  #0")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName+1 |  ldy  #0")
-                    in Cx16VirtualRegisters -> {
-                        val regname = resultRegister.name.lowercase()
-                        if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                            asmgen.out("  lda  $sourceName+1 |  sta  cx16.$regname |  stz  cx16.$regname+1")
-                        else
-                            asmgen.out("  lda  $sourceName+1 |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
-                    }
-                    else -> throw AssemblyError("invalid reg")
+            when(resultRegister) {
+                null, RegisterOrPair.A -> asmgen.out("  lda  $sourceName+1")
+                RegisterOrPair.X -> asmgen.out("  ldx  $sourceName+1")
+                RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName+1")
+                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName+1 |  ldx  #0")
+                RegisterOrPair.AY -> asmgen.out("  lda  $sourceName+1 |  ldy  #0")
+                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName+1 |  ldy  #0")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    if(asmgen.isTargetCpu(CpuType.CPU65c02))
+                        asmgen.out("  lda  $sourceName+1 |  sta  cx16.$regname |  stz  cx16.$regname+1")
+                    else
+                        asmgen.out("  lda  $sourceName+1 |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
                 }
+                else -> throw AssemblyError("invalid reg")
             }
         } else {
-            if(resultToStack) {
-                asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                asmgen.out("  tya |  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                when(resultRegister) {
-                    null, RegisterOrPair.A -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                        asmgen.out("  tya")
-                    }
-                    RegisterOrPair.X -> {
-                        asmgen.out("  pha")
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
-                        asmgen.out("  pla")
-                    }
-                    RegisterOrPair.Y -> {
-                        asmgen.out("  pha")
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                        asmgen.out("  pla")
-                    }
-                    else -> throw AssemblyError("invalid reg")
+            when(resultRegister) {
+                null, RegisterOrPair.A -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.out("  tya")
                 }
+                RegisterOrPair.X -> {
+                    asmgen.out("  pha")
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
+                    asmgen.out("  pla")
+                }
+                RegisterOrPair.Y -> {
+                    asmgen.out("  pha")
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.out("  pla")
+                }
+                else -> throw AssemblyError("invalid reg")
             }
         }
     }
 
-    private fun funcLsb(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+    private fun funcLsb(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val arg = fcall.args.single()
         if (arg.type !in WordDatatypes)
             throw AssemblyError("lsb required word argument")
@@ -1118,72 +1013,60 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
         if (arg is PtIdentifier) {
             val sourceName = asmgen.asmVariableName(arg)
-            if(resultToStack) {
-                asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                when(resultRegister) {
-                    null, RegisterOrPair.A -> asmgen.out("  lda  $sourceName")
-                    RegisterOrPair.X -> asmgen.out("  ldx  $sourceName")
-                    RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName")
-                    RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
-                    RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
-                    RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
-                    in Cx16VirtualRegisters -> {
-                        val regname = resultRegister.name.lowercase()
-                        if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                            asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  stz  cx16.$regname+1")
-                        else
-                            asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
-                    }
-                    else -> throw AssemblyError("invalid reg")
+            when(resultRegister) {
+                null, RegisterOrPair.A -> asmgen.out("  lda  $sourceName")
+                RegisterOrPair.X -> asmgen.out("  ldx  $sourceName")
+                RegisterOrPair.Y -> asmgen.out("  ldy  $sourceName")
+                RegisterOrPair.AX -> asmgen.out("  lda  $sourceName |  ldx  #0")
+                RegisterOrPair.AY -> asmgen.out("  lda  $sourceName |  ldy  #0")
+                RegisterOrPair.XY -> asmgen.out("  ldx  $sourceName |  ldy  #0")
+                in Cx16VirtualRegisters -> {
+                    val regname = resultRegister.name.lowercase()
+                    if(asmgen.isTargetCpu(CpuType.CPU65c02))
+                        asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  stz  cx16.$regname+1")
+                    else
+                        asmgen.out("  lda  $sourceName |  sta  cx16.$regname |  lda  #0 |  sta  cx16.$regname+1")
                 }
+                else -> throw AssemblyError("invalid reg")
             }
         } else {
-            if(resultToStack) {
-                asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
-                //       this is required because the compiler assumes the status bits are set according to what A is (lsb)
-                //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
-                asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-            } else {
-                when(resultRegister) {
-                    null, RegisterOrPair.A -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                        // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
-                        //       this is required because the compiler assumes the status bits are set according to what A is (lsb)
-                        //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
-                    }
-                    RegisterOrPair.X -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
-                        // NOTE: we rely on the fact that the above assignment to XY, assigns the Lsb to X as the last instruction.
-                        //       this is required because the compiler assumes the status bits are set according to what X is (lsb)
-                        //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
-                    }
-                    RegisterOrPair.Y -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                        asmgen.out("  tay |  cpy  #0")
-                    }
-                    RegisterOrPair.AY -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
-                        asmgen.out("  ldy  #0 |  cmp  #0")
-                    }
-                    RegisterOrPair.AX -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
-                        asmgen.out("  ldx  #0 |  cmp  #0")
-                    }
-                    RegisterOrPair.XY -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
-                        asmgen.out("  ldy  #0 |  cpx  #0")
-                    }
-                    in Cx16VirtualRegisters -> {
-                        asmgen.assignExpressionToRegister(fcall.args.single(), resultRegister)
-                        val zero = PtNumber(DataType.UBYTE, 0.0, Position.DUMMY)
-                        zero.parent=fcall
-                        assignAsmGen.assignExpressionToVariable(zero, "cx16.${resultRegister.toString().lowercase()}H", DataType.UBYTE)
-                        asmgen.out("  lda  cx16.r0L")
-                    }
-                    else -> throw AssemblyError("invalid reg")
+            when(resultRegister) {
+                null, RegisterOrPair.A -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
+                    //       this is required because the compiler assumes the status bits are set according to what A is (lsb)
+                    //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
                 }
+                RegisterOrPair.X -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
+                    // NOTE: we rely on the fact that the above assignment to XY, assigns the Lsb to X as the last instruction.
+                    //       this is required because the compiler assumes the status bits are set according to what X is (lsb)
+                    //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
+                }
+                RegisterOrPair.Y -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.out("  tay |  cpy  #0")
+                }
+                RegisterOrPair.AY -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.out("  ldy  #0 |  cmp  #0")
+                }
+                RegisterOrPair.AX -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
+                    asmgen.out("  ldx  #0 |  cmp  #0")
+                }
+                RegisterOrPair.XY -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
+                    asmgen.out("  ldy  #0 |  cpx  #0")
+                }
+                in Cx16VirtualRegisters -> {
+                    asmgen.assignExpressionToRegister(fcall.args.single(), resultRegister)
+                    val zero = PtNumber(DataType.UBYTE, 0.0, Position.DUMMY)
+                    zero.parent=fcall
+                    assignAsmGen.assignExpressionToVariable(zero, "cx16.${resultRegister.toString().lowercase()}H", DataType.UBYTE)
+                    asmgen.out("  lda  cx16.r0L")
+                }
+                else -> throw AssemblyError("invalid reg")
             }
         }
     }

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

@@ -1,933 +0,0 @@
-package prog8.codegen.cpu6502
-
-import prog8.code.ast.*
-import prog8.code.core.*
-import kotlin.math.absoluteValue
-
-internal class ExpressionsAsmGen(private val program: PtProgram,
-                                 private val asmgen: AsmGen6502Internal,
-                                 private val allocator: VariableAllocator) {
-
-    @Deprecated("avoid calling this as it generates slow evalstack based code")
-    internal fun translateExpression(expression: PtExpression) {
-        if (this.asmgen.options.slowCodegenWarnings) {
-            asmgen.errors.warn("slow stack evaluation used for expression", expression.position)
-        }
-        translateExpressionInternal(expression)
-    }
-
-
-    // the rest of the methods are all PRIVATE
-
-
-    private fun translateExpressionInternal(expression: PtExpression) {
-
-        when(expression) {
-            is PtPrefix -> translateExpression(expression)
-            is PtBinaryExpression -> translateExpression(expression)
-            is PtArrayIndexer -> translateExpression(expression)
-            is PtTypeCast -> translateExpression(expression)
-            is PtAddressOf -> translateExpression(expression)
-            is PtMemoryByte -> asmgen.translateDirectMemReadExpressionToRegAorStack(expression, true)
-            is PtNumber -> translateExpression(expression)
-            is PtIdentifier -> translateExpression(expression)
-            is PtFunctionCall -> translateFunctionCallResultOntoStack(expression)
-            is PtBuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
-            is PtContainmentCheck -> translateContainmentCheck(expression)
-            is PtArray, is PtString -> throw AssemblyError("string/array literal value assignment should have been replaced by a variable")
-            is PtRange -> throw AssemblyError("range expression should have been changed into array values")
-            is PtMachineRegister -> throw AssemblyError("machine register ast node should not occur in 6502 codegen it is for IR code")
-            else -> TODO("missing expression asmgen for $expression")
-        }
-    }
-
-    private fun translateContainmentCheck(check: PtContainmentCheck) {
-        asmgen.assignExpressionToRegister(check, RegisterOrPair.A)
-        asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-    }
-
-    private fun translateFunctionCallResultOntoStack(call: PtFunctionCall) {
-        // only for use in nested expression evaluation
-
-        val symbol = asmgen.symbolTable.lookup(call.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        asmgen.saveXbeforeCall(call)
-        asmgen.translateFunctionCall(call)
-        if(sub.regXasResult()) {
-            // store the return value in X somewhere that we can access again below
-            asmgen.out("  stx  P8ZP_SCRATCH_REG")
-        }
-        asmgen.restoreXafterCall(call)
-
-        val returns: List<Pair<RegisterOrStatusflag, DataType>> = sub.returnsWhatWhere()
-        for ((reg, _) in returns) {
-            // result value is in cpu or status registers, put it on the stack instead (as we're evaluating an expression tree)
-            if (reg.registerOrPair != null) {
-                when (reg.registerOrPair!!) {
-                    RegisterOrPair.A -> asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.Y -> asmgen.out("  tya |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.AY -> asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-                    RegisterOrPair.X -> asmgen.out("  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.AX -> asmgen.out("  sta  P8ESTACK_LO,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_HI,x |  dex")
-                    RegisterOrPair.XY -> asmgen.out("  tya |  sta  P8ESTACK_HI,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.push_fac1")
-                    RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.push_fac2")
-                    RegisterOrPair.R0,
-                    RegisterOrPair.R1,
-                    RegisterOrPair.R2,
-                    RegisterOrPair.R3,
-                    RegisterOrPair.R4,
-                    RegisterOrPair.R5,
-                    RegisterOrPair.R6,
-                    RegisterOrPair.R7,
-                    RegisterOrPair.R8,
-                    RegisterOrPair.R9,
-                    RegisterOrPair.R10,
-                    RegisterOrPair.R11,
-                    RegisterOrPair.R12,
-                    RegisterOrPair.R13,
-                    RegisterOrPair.R14,
-                    RegisterOrPair.R15 -> {
-                        asmgen.out(
-                            """
-                            lda  cx16.${reg.registerOrPair.toString().lowercase()}
-                            sta  P8ESTACK_LO,x
-                            lda  cx16.${reg.registerOrPair.toString().lowercase()}+1
-                            sta  P8ESTACK_HI,x
-                            dex
-                        """)
-                    }
-                }
-            } else when(reg.statusflag) {
-                Statusflag.Pc -> {
-                    asmgen.out("""
-                        lda  #0
-                        rol  a
-                        sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pz -> {
-                    asmgen.out("""
-                        beq  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pv -> {
-                    asmgen.out("""
-                        bvs  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pn -> {
-                    asmgen.out("""
-                        bmi  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                null -> {}
-            }
-        }
-    }
-
-    private fun translateExpression(typecast: PtTypeCast) {
-        translateExpressionInternal(typecast.value)
-        when(typecast.value.type) {
-            DataType.UBYTE, DataType.BOOL -> {
-                when(typecast.type) {
-                    DataType.UBYTE, DataType.BYTE -> {}
-                    DataType.UWORD, DataType.WORD -> {
-                        if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                            asmgen.out("  stz  P8ESTACK_HI+1,x")
-                        else
-                            asmgen.out("  lda  #0  |  sta  P8ESTACK_HI+1,x")
-                    }
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_ub2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.BYTE -> {
-                when(typecast.type) {
-                    DataType.UBYTE, DataType.BYTE -> {}
-                    DataType.UWORD, DataType.WORD -> asmgen.signExtendStackLsb(DataType.BYTE)
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_b2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.UWORD -> {
-                when(typecast.type) {
-                    DataType.BYTE, DataType.UBYTE -> {}
-                    DataType.WORD, DataType.UWORD -> {}
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_uw2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.WORD -> {
-                when(typecast.type) {
-                    DataType.BYTE, DataType.UBYTE -> {}
-                    DataType.WORD, DataType.UWORD -> {}
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_w2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.FLOAT -> {
-                when(typecast.type) {
-                    DataType.UBYTE -> asmgen.out(" jsr  floats.stack_float2uw")
-                    DataType.BYTE -> asmgen.out(" jsr  floats.stack_float2w")
-                    DataType.UWORD -> asmgen.out(" jsr  floats.stack_float2uw")
-                    DataType.WORD -> asmgen.out(" jsr  floats.stack_float2w")
-                    DataType.FLOAT -> {}
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.STR -> {
-                if (typecast.type != DataType.UWORD && typecast.type == DataType.STR)
-                    throw AssemblyError("cannot typecast a string into another incompatitble type")
-            }
-            in PassByReferenceDatatypes -> throw AssemblyError("cannot cast pass-by-reference value into another type")
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun translateExpression(expr: PtAddressOf) {
-        val name = asmgen.asmVariableName(expr.identifier)
-        asmgen.out("  lda  #<$name |  sta  P8ESTACK_LO,x |  lda  #>$name  |  sta  P8ESTACK_HI,x  | dex")
-    }
-
-    private fun translateExpression(expr: PtNumber) {
-        when(expr.type) {
-            DataType.UBYTE, DataType.BYTE -> asmgen.out(" lda  #${expr.number.toHex()}  | sta  P8ESTACK_LO,x  | dex")
-            DataType.UWORD, DataType.WORD -> asmgen.out("""
-                lda  #<${expr.number.toHex()}
-                sta  P8ESTACK_LO,x
-                lda  #>${expr.number.toHex()}
-                sta  P8ESTACK_HI,x
-                dex
-            """)
-            DataType.FLOAT -> {
-                val floatConst = allocator.getFloatAsmConst(expr.number)
-                asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
-            }
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun translateExpression(expr: PtIdentifier) {
-        val varname = asmgen.asmVariableName(expr)
-        when(expr.type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("  lda  $varname  |  sta  P8ESTACK_LO,x  |  dex")
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("  lda  $varname  |  sta  P8ESTACK_LO,x  |  lda  $varname+1 |  sta  P8ESTACK_HI,x |  dex")
-            }
-            DataType.FLOAT -> {
-                asmgen.out(" lda  #<$varname |  ldy  #>$varname|  jsr  floats.push_float")
-            }
-            in SplitWordArrayTypes -> {
-                throw AssemblyError("can't push address of split-word array ${expr.position}")
-            }
-            in IterableDatatypes -> {
-                asmgen.out("  lda  #<$varname  |  sta  P8ESTACK_LO,x  |  lda  #>$varname |  sta  P8ESTACK_HI,x |  dex")
-            }
-            else -> throw AssemblyError("stack push weird variable type $expr")
-        }
-    }
-
-    private fun translateExpression(expr: PtBinaryExpression) {
-        // Uses evalstack to evaluate the given expression.  THIS IS SLOW AND SHOULD BE AVOIDED!
-        if(translateSomewhatOptimized(expr.left, expr.operator, expr.right))
-            return
-
-        val leftDt = expr.left.type
-        val rightDt = expr.right.type
-
-        // compare with zero
-        if(expr.operator in ComparisonOperators) {
-            if(leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
-                val rightVal = expr.right.asConstInteger()
-                if(rightVal==0)
-                    return translateComparisonWithZero(expr.left, leftDt, expr.operator)
-            }
-        }
-
-        if(leftDt==DataType.STR && rightDt==DataType.STR && expr.operator in ComparisonOperators)
-            return translateCompareStrings(expr.left, expr.operator, expr.right)
-
-        if((leftDt in ByteDatatypes && rightDt !in ByteDatatypes)
-                || (leftDt in WordDatatypes && rightDt !in WordDatatypes))
-            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")
-
-        // the general, non-optimized cases
-        // TODO optimize more cases.... (or one day just don't use the evalstack at all anymore)
-        translateExpressionInternal(expr.left)
-        translateExpressionInternal(expr.right)
-        when (leftDt) {
-            in ByteDatatypes -> translateBinaryOperatorBytes(expr.operator, leftDt)
-            in WordDatatypes -> translateBinaryOperatorWords(expr.operator, leftDt)
-            DataType.FLOAT -> translateBinaryOperatorFloats(expr.operator)
-            else -> throw AssemblyError("non-numerical datatype")
-        }
-    }
-
-    private fun translateSomewhatOptimized(left: PtExpression, operator: String, right: PtExpression): Boolean {
-        val leftDt = left.type
-        val rightDt = right.type
-        when(operator) {
-            "+" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVal = left.asConstInteger()
-                    val rightVal = right.asConstInteger()
-                    if (leftVal!=null && leftVal in -4..4) {
-                        translateExpressionInternal(right)
-                        if(rightDt in ByteDatatypes) {
-                            val incdec = if(leftVal<0) "dec" else "inc"
-                            repeat(leftVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(leftVal<0) {
-                                repeat(leftVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(leftVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                    else if (rightVal!=null && rightVal in -4..4)
-                    {
-                        translateExpressionInternal(left)
-                        if(leftDt in ByteDatatypes) {
-                            val incdec = if(rightVal<0) "dec" else "inc"
-                            repeat(rightVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(rightVal<0) {
-                                repeat(rightVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(rightVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                }
-            }
-            "-" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = right.asConstInteger()
-                    if (rightVal!=null && rightVal in -4..4)
-                    {
-                        translateExpressionInternal(left)
-                        if(leftDt in ByteDatatypes) {
-                            val incdec = if(rightVal<0) "inc" else "dec"
-                            repeat(rightVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(rightVal>0) {
-                                repeat(rightVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(rightVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                }
-            }
-            ">>" -> {
-                val amount = right.asConstInteger()
-                if(amount!=null) {
-                    translateExpressionInternal(left)
-                    when (leftDt) {
-                        DataType.UBYTE -> {
-                            if (amount <= 2)
-                                repeat(amount) { asmgen.out(" lsr  P8ESTACK_LO+1,x") }
-                            else {
-                                asmgen.out(" lda  P8ESTACK_LO+1,x")
-                                repeat(amount) { asmgen.out(" lsr  a") }
-                                asmgen.out(" sta  P8ESTACK_LO+1,x")
-                            }
-                        }
-                        DataType.BYTE -> {
-                            if (amount <= 2)
-                                repeat(amount) { asmgen.out(" lda  P8ESTACK_LO+1,x |  asl  a |  ror  P8ESTACK_LO+1,x") }
-                            else {
-                                asmgen.out(" lda  P8ESTACK_LO+1,x |  sta  P8ZP_SCRATCH_B1")
-                                repeat(amount) { asmgen.out(" asl  a |  ror  P8ZP_SCRATCH_B1 |  lda  P8ZP_SCRATCH_B1") }
-                                asmgen.out(" sta  P8ESTACK_LO+1,x")
-                            }
-                        }
-                        DataType.UWORD -> {
-                            if(amount>=16) {
-                                if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                                    asmgen.out("  stz  P8ESTACK_LO+1,x |  stz  P8ESTACK_HI+1,x")
-                                else
-                                    asmgen.out("  lda  #0 |  sta  P8ESTACK_LO+1,x |  sta  P8ESTACK_HI+1,x")
-                                return true
-                            }
-                            var amountLeft = amount
-                            while (amountLeft >= 7) {
-                                asmgen.out(" jsr  math.shift_right_uw_7")
-                                amountLeft -= 7
-                            }
-                            if (amountLeft in 0..2)
-                                repeat(amountLeft) { asmgen.out(" lsr  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
-                            else
-                                asmgen.out(" jsr  math.shift_right_uw_$amountLeft")
-                        }
-                        DataType.WORD -> {
-                            if(amount>=16) {
-                                asmgen.out("""
-                                    lda  P8ESTACK_HI+1,x
-                                    bmi  +
-                                    lda  #0
-                                    sta  P8ESTACK_LO+1,x
-                                    sta  P8ESTACK_HI+1,x
-                                    beq  ++
-+                                   lda  #255
-                                    sta  P8ESTACK_LO+1,x
-                                    sta  P8ESTACK_HI+1,x
-+""")
-                                return true
-                            }
-                            var amountLeft = amount
-                            while (amountLeft >= 7) {
-                                asmgen.out(" jsr  math.shift_right_w_7")
-                                amountLeft -= 7
-                            }
-                            if (amountLeft in 0..2)
-                                repeat(amountLeft) { asmgen.out(" lda  P8ESTACK_HI+1,x |  asl  a  |  ror  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
-                            else
-                                asmgen.out(" jsr  math.shift_right_w_$amountLeft")
-                        }
-                        else -> throw AssemblyError("weird type")
-                    }
-                    return true
-                }
-            }
-            "<<" -> {
-                val amount = right.asConstInteger()
-                if(amount!=null) {
-                    translateExpressionInternal(left)
-                    if (leftDt in ByteDatatypes) {
-                        if (amount <= 2)
-                            repeat(amount) { asmgen.out("  asl  P8ESTACK_LO+1,x") }
-                        else {
-                            asmgen.out("  lda  P8ESTACK_LO+1,x")
-                            repeat(amount) { asmgen.out("  asl  a") }
-                            asmgen.out("  sta  P8ESTACK_LO+1,x")
-                        }
-                    } else {
-                        var amountLeft = amount
-                        while (amountLeft >= 7) {
-                            asmgen.out(" jsr  math.shift_left_w_7")
-                            amountLeft -= 7
-                        }
-                        if (amountLeft in 0..2)
-                            repeat(amountLeft) { asmgen.out("  asl  P8ESTACK_LO+1,x |  rol  P8ESTACK_HI+1,x") }
-                        else
-                            asmgen.out(" jsr  math.shift_left_w_$amountLeft")
-                    }
-                    return true
-                }
-            }
-            "*" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVar = left as? PtIdentifier
-                    val rightVar = right as? PtIdentifier
-                    if(leftVar!=null && rightVar!=null && leftVar==rightVar) {
-                        translateSquared(leftVar, leftDt)
-                        return true
-                    }
-                }
-
-                val value = right as? PtNumber
-                if(value!=null) {
-                    if(rightDt in IntegerDatatypes) {
-                        val amount = value.number.toInt()
-                        if(amount==2) {
-                            // optimize x*2 common case
-                            translateExpressionInternal(left)
-                            if(leftDt in ByteDatatypes) {
-                                asmgen.out("  asl  P8ESTACK_LO+1,x")
-                            } else {
-                                asmgen.out("  asl  P8ESTACK_LO+1,x |  rol  P8ESTACK_HI+1,x")
-                            }
-                            return true
-                        }
-                        when(rightDt) {
-                            DataType.UBYTE -> {
-                                if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return true
-                                }
-                            }
-                            DataType.BYTE -> {
-                                if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return true
-                                }
-                                if(amount.absoluteValue in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.stack_mul_byte_${amount.absoluteValue}")
-                                    return true
-                                }
-                            }
-                            DataType.UWORD -> {
-                                if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return true
-                                }
-                            }
-                            DataType.WORD -> {
-                                if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return true
-                                }
-                                if(amount.absoluteValue in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.stack_mul_word_${amount.absoluteValue}")
-                                    return true
-                                }
-                            }
-                            else -> {}
-                        }
-                    }
-                }
-            }
-            "/" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = right.asConstInteger()
-                    if(rightVal!=null && rightVal==2) {
-                        translateExpressionInternal(left)
-                        when (leftDt) {
-                            DataType.UBYTE -> {
-                                asmgen.out("  lsr  P8ESTACK_LO+1,x")
-                            }
-                            DataType.UWORD -> {
-                                asmgen.out("  lsr  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x")
-                            }
-                            DataType.BYTE -> {
-                                // signed divide using shift needs adjusting of negative value to get correct rounding towards zero
-                                asmgen.out("""
-                                    lda  P8ESTACK_LO+1,x
-                                    bpl  +
-                                    inc  P8ESTACK_LO+1,x
-                                    lda  P8ESTACK_LO+1,x
-+                                   asl  a
-                                    ror  P8ESTACK_LO+1,x""")
-                            }
-                            DataType.WORD -> {
-                                // signed divide using shift needs adjusting of negative value to get correct rounding towards zero
-                                asmgen.out("""
-                                    lda  P8ESTACK_HI+1,x
-                                    bpl  ++
-                                    inc  P8ESTACK_LO+1,x
-                                    bne  +
-                                    inc  P8ESTACK_HI+1,x
-+                                   lda  P8ESTACK_HI+1,x
-+                                   asl  a
-                                    ror  P8ESTACK_HI+1,x
-                                    ror  P8ESTACK_LO+1,x""")
-                            }
-                            else -> throw AssemblyError("weird dt")
-                        }
-                        return true
-                    }
-                }
-            }
-        }
-
-        return false
-    }
-
-    private fun translateComparisonWithZero(expr: PtExpression, dt: DataType, operator: String) {
-        if(expr.isSimple()) {
-            if(operator=="!=") {
-                when (dt) {
-                    in ByteDatatypes -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.A, dt == DataType.BYTE)
-                        asmgen.out("""
-                            beq  +
-                            lda  #1
-+                           sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    in WordDatatypes -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY, dt == DataType.WORD)
-                        asmgen.out("""
-                            sty  P8ZP_SCRATCH_B1 
-                            ora  P8ZP_SCRATCH_B1
-                            beq  +
-                            lda  #1
-+                           sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    DataType.FLOAT -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.FAC1, true)
-                        asmgen.out("""
-                            jsr  floats.SIGN
-                            sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    else -> {}
-                }
-            }
-            /* operator == is not worth it to special case, the code is mostly larger */
-        }
-        translateExpressionInternal(expr)
-        when(operator) {
-            "==" -> {
-                when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> asmgen.out("  jsr  prog8_lib.equalzero_b")
-                    DataType.UWORD, DataType.WORD -> asmgen.out("  jsr  prog8_lib.equalzero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.equal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "!=" -> {
-                when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> asmgen.out("  jsr  prog8_lib.notequalzero_b")
-                    DataType.UWORD, DataType.WORD -> asmgen.out("  jsr  prog8_lib.notequalzero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.notequal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "<" -> {
-                if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(PtNumber.fromBoolean(false, expr.position))
-                when(dt) {
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lesszero_b")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.lesszero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.less_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            ">" -> {
-                when(dt) {
-                    DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.greaterzero_ub")
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.greaterzero_sb")
-                    DataType.UWORD -> asmgen.out("  jsr  prog8_lib.greaterzero_uw")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.greaterzero_sw")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.greater_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "<=" -> {
-                when(dt) {
-                    DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.equalzero_b")
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lessequalzero_sb")
-                    DataType.UWORD -> asmgen.out("  jsr  prog8_lib.equalzero_w")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.lessequalzero_sw")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.lessequal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            ">=" -> {
-                if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(PtNumber.fromBoolean(true, expr.position))
-                when(dt) {
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sb")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sw")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.greaterequal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            else -> throw AssemblyError("invalid comparison operator")
-        }
-    }
-
-    private fun translateSquared(variable: PtIdentifier, dt: DataType) {
-        val asmVar = asmgen.asmVariableName(variable)
-        when(dt) {
-            DataType.BYTE, DataType.UBYTE -> {
-                asmgen.out("  lda  $asmVar")
-                asmgen.signExtendAYlsb(dt)
-                asmgen.out("  jsr  math.square")
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("  lda  $asmVar |  ldy  $asmVar+1 |  jsr  math.square")
-            }
-            else -> throw AssemblyError("require integer dt for square")
-        }
-        asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-    }
-
-    private fun translateExpression(expr: PtPrefix) {
-        translateExpressionInternal(expr.value)
-        when(expr.operator) {
-            "+" -> {}
-            "-" -> {
-                when(expr.type) {
-                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.neg_b")
-                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.neg_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.neg_f")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            "~" -> {
-                when(expr.type) {
-                    in ByteDatatypes ->
-                        asmgen.out("""
-                            lda  P8ESTACK_LO+1,x
-                            eor  #255
-                            sta  P8ESTACK_LO+1,x
-                            """)
-                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.inv_word")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            else -> throw AssemblyError("invalid prefix operator ${expr.operator}")
-        }
-    }
-
-    private fun translateExpression(arrayExpr: PtArrayIndexer) {
-        val elementDt = arrayExpr.type
-        val arrayVarName = asmgen.asmVariableName(arrayExpr.variable)
-
-        if(arrayExpr.variable.type==DataType.UWORD) {
-            // indexing a pointer var instead of a real array or string
-            if(elementDt !in ByteDatatypes)
-                throw AssemblyError("non-array var indexing requires bytes dt")
-            if(arrayExpr.index.type != DataType.UBYTE)
-                throw AssemblyError("non-array var indexing requires bytes index")
-            asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-            if(asmgen.isZpVar(arrayExpr.variable)) {
-                asmgen.out("  lda  ($arrayVarName),y")
-            } else {
-                asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
-                asmgen.out("  lda  (P8ZP_SCRATCH_W1),y")
-            }
-            asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-            return
-        }
-
-        if(arrayExpr.splitWords)
-            TODO("split words expression ${arrayExpr.position}")
-
-        val constIndexNum = arrayExpr.index.asConstInteger()
-        if(constIndexNum!=null) {
-            val indexValue = constIndexNum * program.memsizer.memorySize(elementDt)
-            when(elementDt) {
-                in ByteDatatypes -> {
-                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  dex")
-                }
-                in WordDatatypes -> {
-                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+$indexValue+1 |  sta  P8ESTACK_HI,x |  dex")
-                }
-                DataType.FLOAT -> {
-                    asmgen.out("  lda  #<($arrayVarName+$indexValue) |  ldy  #>($arrayVarName+$indexValue) |  jsr  floats.push_float")
-                }
-                else -> throw AssemblyError("weird element type")
-            }
-        } else {
-            when(elementDt) {
-                in ByteDatatypes -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-                    asmgen.out(" lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  dex")
-                }
-                in WordDatatypes -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-                    asmgen.out(" lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+1,y |  sta  P8ESTACK_HI,x |  dex")
-                }
-                DataType.FLOAT -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.A)
-                    asmgen.out("""
-                        ldy  #>$arrayVarName
-                        clc
-                        adc  #<$arrayVarName
-                        bcc  +
-                        iny
-+                       jsr  floats.push_float""")
-                }
-                else -> throw AssemblyError("weird dt")
-            }
-
-        }
-    }
-
-    private fun translateBinaryOperatorBytes(operator: String, types: DataType) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
-            "/" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
-            "%" -> {
-                if(types==DataType.BYTE)
-                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
-                asmgen.out("  jsr prog8_lib.remainder_ub")
-            }
-            "+" -> asmgen.out("""
-                lda  P8ESTACK_LO+2,x
-                clc
-                adc  P8ESTACK_LO+1,x
-                inx
-                sta  P8ESTACK_LO+1,x
-                """)
-            "-" -> asmgen.out("""
-                lda  P8ESTACK_LO+2,x
-                sec
-                sbc  P8ESTACK_LO+1,x
-                inx
-                sta  P8ESTACK_LO+1,x
-                """)
-            "<<" -> asmgen.out("  jsr  prog8_lib.shiftleft_b")
-            ">>" -> asmgen.out("  jsr  prog8_lib.shiftright_b")
-            "<" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.less_ub" else "  jsr  prog8_lib.less_b")
-            ">" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greater_ub" else "  jsr  prog8_lib.greater_b")
-            "<=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.lesseq_ub" else "  jsr  prog8_lib.lesseq_b")
-            ">=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greatereq_ub" else "  jsr  prog8_lib.greatereq_b")
-            "==" -> asmgen.out("  jsr  prog8_lib.equal_b")
-            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_b")
-            "&" -> asmgen.out("  jsr  prog8_lib.bitand_b")
-            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_b")
-            "|" -> asmgen.out("  jsr  prog8_lib.bitor_b")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateBinaryOperatorWords(operator: String, dt: DataType) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  prog8_lib.mul_word")
-            "/" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
-            "%" -> {
-                if(dt==DataType.WORD)
-                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
-                asmgen.out("  jsr prog8_lib.remainder_uw")
-            }
-            "+" -> asmgen.out("  jsr  prog8_lib.add_w")
-            "-" -> asmgen.out("  jsr  prog8_lib.sub_w")
-            "<<" -> asmgen.out("  jsr  math.shift_left_w")
-            ">>" -> {
-                if(dt==DataType.UWORD)
-                    asmgen.out("  jsr  math.shift_right_uw")
-                else
-                    asmgen.out("  jsr  math.shift_right_w")
-            }
-            "<" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.less_uw" else "  jsr  prog8_lib.less_w")
-            ">" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greater_uw" else "  jsr  prog8_lib.greater_w")
-            "<=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.lesseq_uw" else "  jsr  prog8_lib.lesseq_w")
-            ">=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greatereq_uw" else "  jsr  prog8_lib.greatereq_w")
-            "==" -> asmgen.out("  jsr  prog8_lib.equal_w")
-            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_w")
-            "&" -> asmgen.out("  jsr  prog8_lib.bitand_w")
-            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_w")
-            "|" -> asmgen.out("  jsr  prog8_lib.bitor_w")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateBinaryOperatorFloats(operator: String) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  floats.mul_f")
-            "/" -> asmgen.out("  jsr  floats.div_f")
-            "+" -> asmgen.out("  jsr  floats.add_f")
-            "-" -> asmgen.out("  jsr  floats.sub_f")
-            "<" -> asmgen.out("  jsr  floats.less_f")
-            ">" -> asmgen.out("  jsr  floats.greater_f")
-            "<=" -> asmgen.out("  jsr  floats.lesseq_f")
-            ">=" -> asmgen.out("  jsr  floats.greatereq_f")
-            "==" -> asmgen.out("  jsr  floats.equal_f")
-            "!=" -> asmgen.out("  jsr  floats.notequal_f")
-            "%", "<<", ">>", "&", "^", "|" -> throw AssemblyError("requires integer datatype")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateCompareStrings(s1: PtExpression, operator: String, s2: PtExpression) {
-        asmgen.assignExpressionToVariable(s1, "prog8_lib.strcmp_expression._arg_s1", DataType.UWORD)
-        asmgen.assignExpressionToVariable(s2, "prog8_lib.strcmp_expression._arg_s2", DataType.UWORD)
-        asmgen.out(" jsr  prog8_lib.strcmp_expression")    // result  of compare is in A
-        compareStringsProcessResultInA(operator)
-    }
-
-    private fun compareStringsProcessResultInA(operator: String) {
-        when(operator) {
-            "==" -> asmgen.out(" and  #1 |  eor  #1 |  sta  P8ESTACK_LO,x")
-            "!=" -> asmgen.out(" and  #1 |  sta  P8ESTACK_LO,x")
-            "<=" -> asmgen.out("""
-                bpl  +
-                lda  #1
-                bne  ++
-+               lda  #0
-+               sta  P8ESTACK_LO,x""")
-            ">=" -> asmgen.out("""
-                bmi  +
-                lda  #1
-                bne  ++
-+               lda  #0
-+               sta  P8ESTACK_LO,x""")
-            "<" -> asmgen.out("""
-                bmi  +
-                lda  #0
-                beq  ++
-+               lda  #1
-+               sta  P8ESTACK_LO,x""")
-            ">" -> asmgen.out("""
-                bpl  +
-                lda  #0
-                beq  ++
-+               lda  #1
-+               sta  P8ESTACK_LO,x""")
-        }
-        asmgen.out("  dex")
-    }
-}

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

@@ -6,26 +6,6 @@ import prog8.code.ast.PtSub
 import prog8.code.core.*
 
 
-internal fun IPtSubroutine.regXasResult(): Boolean =
-    (this is PtAsmSub) && this.returns.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-
-internal fun IPtSubroutine.shouldSaveX(): Boolean =
-    this.regXasResult() || (this is PtAsmSub && (CpuRegister.X in this.clobbers || regXasParam()))
-
-internal fun PtAsmSub.regXasParam(): Boolean =
-    parameters.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-
-internal class KeepAresult(val saveOnEntry: Boolean, val saveOnReturn: Boolean)
-
-internal fun PtAsmSub.shouldKeepA(): KeepAresult {
-    // determine if A's value should be kept when preparing for calling the subroutine, and when returning from it
-
-    // it seems that we never have to save A when calling? will be loaded correctly after setup.
-    // but on return it depends on wether the routine returns something in A.
-    val saveAonReturn = returns.any { it.first.registerOrPair==RegisterOrPair.A || it.first.registerOrPair==RegisterOrPair.AY || it.first.registerOrPair==RegisterOrPair.AX }
-    return KeepAresult(false, saveAonReturn)
-}
-
 internal fun IPtSubroutine.returnsWhatWhere(): List<Pair<RegisterOrStatusflag, DataType>> {
     when(this) {
         is PtAsmSub -> {

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

@@ -5,9 +5,10 @@ import prog8.code.ast.*
 import prog8.code.core.*
 import kotlin.math.absoluteValue
 
-internal class ForLoopsAsmGen(private val program: PtProgram,
-                              private val asmgen: AsmGen6502Internal,
-                              private val zeropage: Zeropage) {
+internal class ForLoopsAsmGen(
+    private val asmgen: AsmGen6502Internal,
+    private val zeropage: Zeropage
+) {
 
     internal fun translate(stmt: PtForLoop) {
         val iterableDt = stmt.iterable.type
@@ -382,7 +383,7 @@ $loopLabel          sty  $indexVar
                     // allocate index var on ZP if possible
                     val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
                     result.fold(
-                        success = { (address,_)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
                         failure = { asmgen.out("$indexVar    .byte  0") }
                     )
                 } else {

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

@@ -11,42 +11,10 @@ import prog8.codegen.cpu6502.assignment.TargetStorageKind
 internal class FunctionCallAsmGen(private val program: PtProgram, private val asmgen: AsmGen6502Internal) {
 
     internal fun translateFunctionCallStatement(stmt: PtFunctionCall) {
-        saveXbeforeCall(stmt)
         translateFunctionCall(stmt)
-        restoreXafterCall(stmt)
         // just ignore any result values from the function call.
     }
 
-    internal fun saveXbeforeCall(stmt: PtFunctionCall) {
-        val symbol = asmgen.symbolTable.lookup(stmt.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        if(sub.shouldSaveX()) {
-            if(sub is PtAsmSub) {
-                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
-                if (regSaveOnStack)
-                    asmgen.saveRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnEntry)
-                else
-                    asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
-            } else
-                asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
-        }
-    }
-
-    internal fun restoreXafterCall(stmt: PtFunctionCall) {
-        val symbol = asmgen.symbolTable.lookup(stmt.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        if(sub.shouldSaveX()) {
-            if(sub is PtAsmSub) {
-                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
-                if (regSaveOnStack)
-                    asmgen.restoreRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnReturn)
-                else
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
-            } else
-                asmgen.restoreRegisterLocal(CpuRegister.X)
-        }
-    }
-
     internal fun optimizeIntArgsViaRegisters(sub: PtSub) =
         (sub.parameters.size==1 && sub.parameters[0].type in IntegerDatatypes)
                 || (sub.parameters.size==2 && sub.parameters[0].type in ByteDatatypes && sub.parameters[1].type in ByteDatatypes)
@@ -63,8 +31,8 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
 
         if(sub is PtAsmSub) {
             argumentsViaRegisters(sub, call)
-            if (sub.inline && asmgen.options.optimize) {
-                // inline the subroutine.
+            if (sub.inline) {
+                // inline the subroutine. (regardless of optimization settings!)
                 // we do this by copying the subroutine's statements at the call site.
                 // NOTE: *if* there is a return statement, it will be the only one, and the very last statement of the subroutine
                 // (this condition has been enforced by an ast check earlier)

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

@@ -13,7 +13,6 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         val targetIdent = stmt.target.identifier
         val targetMemory = stmt.target.memory
         val targetArrayIdx = stmt.target.array
-        val scope = stmt.definingISub()
         when {
             targetIdent!=null -> {
                 val what = asmgen.asmVariableName(targetIdent)
@@ -76,7 +75,6 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         dec  ${asmArrayvarname}_msb+$constIndex
 +       dec  ${asmArrayvarname}_lsb+$constIndex""")
                     } else {
-                        asmgen.saveRegisterLocal(CpuRegister.X, scope!!)
                         asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.X)
                         if(incr)
                             asmgen.out(" inc  ${asmArrayvarname}_lsb,x |  bne  + |  inc  ${asmArrayvarname}_msb,x |+")
@@ -86,14 +84,30 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         bne  +
         dec  ${asmArrayvarname}_msb,x
 +       dec  ${asmArrayvarname}_lsb,x""")
-                        asmgen.restoreRegisterLocal(CpuRegister.X)
                     }
                     return
                 }
                 if(constIndex!=null) {
                     val indexValue = constIndex * program.memsizer.memorySize(elementDt)
                     when(elementDt) {
-                        in ByteDatatypes -> asmgen.out(if (incr) "  inc  $asmArrayvarname+$indexValue" else "  dec  $asmArrayvarname+$indexValue")
+                        in ByteDatatypes -> {
+                            if(targetArrayIdx.usesPointerVariable) {
+                                asmgen.out("""
+                                    lda  $asmArrayvarname
+                                    clc
+                                    adc  #$indexValue
+                                    sta  (+) +1
+                                    lda  $asmArrayvarname+1
+                                    adc  #0
+                                    sta  (+) +2""")
+                                if(incr)
+                                    asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                                else
+                                    asmgen.out("+\tdec  ${'$'}ffff\t; modified")
+                            } else {
+                                asmgen.out(if (incr) "  inc  $asmArrayvarname+$indexValue" else "  dec  $asmArrayvarname+$indexValue")
+                            }
+                        }
                         in WordDatatypes -> {
                             if(incr)
                                 asmgen.out(" inc  $asmArrayvarname+$indexValue |  bne  + |  inc  $asmArrayvarname+$indexValue+1 |+")
@@ -113,11 +127,25 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                 }
                 else
                 {
-                    asmgen.saveRegisterLocal(CpuRegister.X, scope!!)
                     asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.X)
                     when(elementDt) {
                         in ByteDatatypes -> {
-                            asmgen.out(if(incr) "  inc  $asmArrayvarname,x" else "  dec  $asmArrayvarname,x")
+                            if(targetArrayIdx.usesPointerVariable) {
+                                asmgen.out("""
+                                    txa
+                                    clc
+                                    adc  $asmArrayvarname
+                                    sta  (+) +1
+                                    lda  $asmArrayvarname+1
+                                    adc  #0
+                                    sta  (+) +2""")
+                                if(incr)
+                                    asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                                else
+                                    asmgen.out("+\tdec  ${'$'}ffff\t; modified")
+                            } else {
+                                asmgen.out(if (incr) "  inc  $asmArrayvarname,x" else "  dec  $asmArrayvarname,x")
+                            }
                         }
                         in WordDatatypes -> {
                             if(incr)
@@ -127,8 +155,7 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         lda  $asmArrayvarname,x
         bne  +
         dec  $asmArrayvarname+1,x
-+       dec  $asmArrayvarname,x 
-""")
++       dec  $asmArrayvarname,x""")
                         }
                         DataType.FLOAT -> {
                             asmgen.out("""
@@ -141,7 +168,6 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                         }
                         else -> throw AssemblyError("weird array elt dt")
                     }
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
             }
         }

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

@@ -75,8 +75,6 @@ internal class ProgramAndVarsGen(
         asmgen.out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
         asmgen.out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
         asmgen.out(".weak")   // hack to allow user to override the following two with command line redefinition (however, just use '-esa' command line option instead!)
-        asmgen.out("P8ESTACK_LO = ${compTarget.machine.ESTACK_LO.toHex()}")
-        asmgen.out("P8ESTACK_HI = ${compTarget.machine.ESTACK_HI.toHex()}")
         asmgen.out(".endweak")
 
         if(options.symbolDefs.isNotEmpty()) {
@@ -271,9 +269,7 @@ internal class ProgramAndVarsGen(
 
     internal fun translateAsmSubroutine(sub: PtAsmSub) {
         if(sub.inline) {
-            if(options.optimize) {
-                return
-            }
+            return      // subroutine gets inlined at call site.
         }
 
         asmgen.out("")
@@ -373,12 +369,6 @@ internal class ProgramAndVarsGen(
                 else -> throw AssemblyError("weird dt for extravar $dt")
             }
         }
-        if(asmGenInfo.usedRegsaveA)      // will probably never occur
-            asmgen.out("prog8_regsaveA     .byte  ?")
-        if(asmGenInfo.usedRegsaveX)
-            asmgen.out("prog8_regsaveX     .byte  ?")
-        if(asmGenInfo.usedRegsaveY)
-            asmgen.out("prog8_regsaveY     .byte  ?")
         if(asmGenInfo.usedFloatEvalResultVar1)
             asmgen.out("$subroutineFloatEvalResultVar1    .fill  ${options.compTarget.machine.FLOAT_MEM_SIZE}")
         if(asmGenInfo.usedFloatEvalResultVar2)
@@ -438,12 +428,12 @@ internal class ProgramAndVarsGen(
                 asmgen.out("""
                     lda  #<${name}_init_value
                     ldy  #>${name}_init_value
-                    sta  cx16.r0L
-                    sty  cx16.r0H
+                    sta  cx16.r0
+                    sty  cx16.r0+1
                     lda  #<${name}
                     ldy  #>${name}
-                    sta  cx16.r1L
-                    sty  cx16.r1H
+                    sta  cx16.r1
+                    sty  cx16.r1+1
                     lda  #<$size
                     ldy  #>$size
                     jsr  sys.memcopy""")
@@ -462,7 +452,6 @@ internal class ProgramAndVarsGen(
         }
 
         asmgen.out("""+        
-                    ldx  #127       ; init estack ptr (half page)
                     clv
                     clc""")
     }

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

@@ -0,0 +1,265 @@
+package prog8.codegen.cpu6502.assignment
+
+import prog8.code.ast.PtBinaryExpression
+import prog8.code.core.*
+import prog8.codegen.cpu6502.AsmGen6502Internal
+
+//
+// This contains codegen for stack-based evaluation of binary expressions.
+// It uses the CPU stack so depth is limited.
+// It is called "as a last resort" if the optimized codegen path is unable
+// to come up with a special case of the expression.
+//
+internal class AnyExprAsmGen(
+    private val asmgen: AsmGen6502Internal
+) {
+    fun assignAnyExpressionUsingStack(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.type) {
+            in ByteDatatypes -> {
+                if(expr.left.type in ByteDatatypes && expr.right.type in ByteDatatypes)
+                    return assignByteBinExpr(expr, assign)
+                if (expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
+                    require(expr.operator in ComparisonOperators)
+                    TODO("words operands comparison -> byte")
+                }
+                if (expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
+                    require(expr.operator in ComparisonOperators)
+                    return assignFloatBinExpr(expr, assign)
+                }
+                TODO("weird expr operand types")
+            }
+            in WordDatatypes -> {
+                require(expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
+                    "both operands must be words"
+                }
+                return assignWordBinExpr(expr)
+            }
+            DataType.FLOAT -> {
+                require(expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
+                    "both operands must be floats"
+                }
+                return assignFloatBinExpr(expr, assign)
+            }
+            else -> throw AssemblyError("weird expression type in assignment")
+        }
+    }
+
+    private fun assignWordBinExpr(expr: PtBinaryExpression): Boolean {
+        when(expr.operator) {
+            "+" -> {
+                TODO("word + at ${expr.position}")
+            }
+            "-" -> {
+                TODO("word - at ${expr.position}")
+            }
+            "*" -> {
+                TODO("word * at ${expr.position}")
+            }
+            "/" -> {
+                TODO("word / at ${expr.position}")
+            }
+            "<<" -> {
+                TODO("word << at ${expr.position}")
+            }
+            ">>" -> {
+                TODO("word >> at ${expr.position}")
+            }
+            "%" -> {
+                TODO("word % at ${expr.position}")
+            }
+            "&", "and" -> {
+                TODO("word and at ${expr.position}")
+            }
+            "|", "or" -> {
+                TODO("word or at ${expr.position}")
+            }
+            "^", "xor" -> {
+                TODO("word xor at ${expr.position}")
+            }
+            "==" -> {
+                TODO("word == at ${expr.position}")
+            }
+            "!=" -> {
+                TODO("word != at ${expr.position}")
+            }
+            "<" -> {
+                TODO("word < at ${expr.position}")
+            }
+            "<=" -> {
+                TODO("word <= at ${expr.position}")
+            }
+            ">" -> {
+                TODO("word > at ${expr.position}")
+            }
+            ">=" -> {
+                TODO("word >= at ${expr.position}")
+            }
+            else -> return false
+        }
+    }
+
+    private fun assignByteBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.operator) {
+            "+" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  clc |  adc  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "-" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  sec |  sbc  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "*" -> {
+                TODO("byte * at ${expr.position}")
+            }
+            "/" -> {
+                TODO("byte / at ${expr.position}")
+            }
+            "<<" -> {
+                TODO("byte << at ${expr.position}")
+            }
+            ">>" -> {
+                TODO("byte >> at ${expr.position}")
+            }
+            "%" -> {
+                TODO("byte % at ${expr.position}")
+            }
+            "&", "and" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  and  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "|", "or" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  ora  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "^", "xor" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  eor  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "==" -> {
+                TODO("byte == at ${expr.position}")
+            }
+            "!=" -> {
+                TODO("byte != at ${expr.position}")
+            }
+            "<" -> {
+                TODO("byte < at ${expr.position}")
+            }
+            "<=" -> {
+                TODO("byte <= at ${expr.position}")
+            }
+            ">" -> {
+                TODO("byte > at ${expr.position}")
+            }
+            ">=" -> {
+                TODO("byte >= at ${expr.position}")
+            }
+            else -> return false
+        }
+    }
+
+    private fun assignFloatBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.operator) {
+            "+" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+                if(!expr.right.isSimple()) asmgen.pushFAC1()
+                asmgen.assignExpressionToRegister(expr.right, RegisterOrPair.FAC2, true)
+                if(!expr.right.isSimple()) asmgen.popFAC1()
+                asmgen.out("  jsr  floats.FADDT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "-" -> {
+                asmgen.assignExpressionToRegister(expr.right, RegisterOrPair.FAC1, true)
+                if(!expr.left.isSimple()) asmgen.pushFAC1()
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC2, true)
+                if(!expr.left.isSimple()) asmgen.popFAC1()
+                asmgen.out("  jsr  floats.FSUBT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "*" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+                if(!expr.right.isSimple()) asmgen.pushFAC1()
+                asmgen.assignExpressionToRegister(expr.right, RegisterOrPair.FAC2, true)
+                if(!expr.right.isSimple()) asmgen.popFAC1()
+                asmgen.out("  jsr  floats.FMULTT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "/" -> {
+                asmgen.assignExpressionToRegister(expr.right, RegisterOrPair.FAC1, true)
+                if(!expr.left.isSimple()) asmgen.pushFAC1()
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC2, true)
+                if(!expr.left.isSimple()) asmgen.popFAC1()
+                asmgen.out("  jsr  floats.FDIVT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "==" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_equal_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "!=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_notequal_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "<" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_less_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            ">" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_greater_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "<=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_lesseq_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            ">=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_greatereq_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            else -> TODO("float expression operator ${expr.operator}")
+        }
+    }
+
+    private fun setupFloatComparisonFAC1vsVarAY(expr: PtBinaryExpression) {
+        asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+        if(!expr.right.isSimple()) asmgen.pushFAC1()
+        asmgen.assignExpressionToVariable(expr.right, "floats.floats_temp_var", DataType.FLOAT)
+        if(!expr.right.isSimple()) asmgen.popFAC1()
+        asmgen.out("  lda  #<floats.floats_temp_var |  ldy  #>floats.floats_temp_var")
+    }
+}

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

@@ -10,8 +10,7 @@ internal enum class TargetStorageKind {
     VARIABLE,
     ARRAY,
     MEMORY,
-    REGISTER,
-    STACK
+    REGISTER
 }
 
 internal enum class SourceStorageKind {
@@ -20,7 +19,6 @@ internal enum class SourceStorageKind {
     ARRAY,
     MEMORY,
     REGISTER,
-    STACK,              // value is already present on stack
     EXPRESSION,         // expression in ast-form, still to be evaluated
 }
 
@@ -120,7 +118,7 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
             TargetStorageKind.MEMORY -> {
                 left isSameAs memory!!
             }
-            TargetStorageKind.REGISTER, TargetStorageKind.STACK -> {
+            TargetStorageKind.REGISTER -> {
                 false
             }
         }

codeGenCpu6502/test/TestCodegen.kt

@@ -106,7 +106,7 @@ class TestCodegen: FunSpec({
         Files.deleteIfExists(Path("${result.name}.asm"))
     }
 
-    test("64tass assembler available? - if this fails you need to install 64tass in the path") {
+    test("64tass assembler available? - if this fails you need to install 64tass version 1.58 or newer in the path") {
         val command = mutableListOf("64tass", "--version")
         shouldNotThrowAny {
             val proc = ProcessBuilder(command).start()

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

@@ -15,7 +15,7 @@ class ExperiCodeGen: ICodeGeneratorBackend {
         symbolTable: SymbolTable,
         options: CompilationOptions,
         errors: IErrorReporter
-    ): IAssemblyProgram? {
+    ): IAssemblyProgram {
 
         // you could write a code generator directly on the PtProgram AST,
         // but you can also use the Intermediate Representation to build a codegen on:

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

@@ -13,7 +13,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         if(assignment.target.children.single() is PtMachineRegister)
             throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
 
-        return translateRegularAssign(assignment)
+        val chunks = translateRegularAssign(assignment)
+        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(assignment.position)
+        return chunks
     }
 
     internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
@@ -24,7 +26,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         val memory = augAssign.target.memory
         val array = augAssign.target.array
 
-        return if(ident!=null) {
+        val chunks = if(ident!=null) {
             assignVarAugmented(ident.name, augAssign)
         } else if(memory != null) {
             if(memory.address is PtNumber)
@@ -39,6 +41,8 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         } else {
             fallbackAssign(augAssign)
         }
+        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(augAssign.position)
+        return chunks
     }
 
     private fun assignMemoryAugmented(
@@ -48,15 +52,15 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         val value = assignment.value
         val vmDt = irType(value.type)
         return when(assignment.operator) {
-            "+" -> expressionEval.operatorPlusInplace(address, null, vmDt, value)
-            "-" -> expressionEval.operatorMinusInplace(address, null, vmDt, value)
-            "*" -> expressionEval.operatorMultiplyInplace(address, null, vmDt, value)
-            "/" -> expressionEval.operatorDivideInplace(address, null, vmDt, value.type in SignedDatatypes, value)
-            "|" -> expressionEval.operatorOrInplace(address, null, vmDt, value)
-            "&" -> expressionEval.operatorAndInplace(address, null, vmDt, value)
-            "^" -> expressionEval.operatorXorInplace(address, null, vmDt, value)
-            "<<" -> expressionEval.operatorShiftLeftInplace(address, null, vmDt, value)
-            ">>" -> expressionEval.operatorShiftRightInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            "+=" -> expressionEval.operatorPlusInplace(address, null, vmDt, value)
+            "-=" -> expressionEval.operatorMinusInplace(address, null, vmDt, value)
+            "*=" -> expressionEval.operatorMultiplyInplace(address, null, vmDt, value)
+            "/=" -> expressionEval.operatorDivideInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            "|=" -> expressionEval.operatorOrInplace(address, null, vmDt, value)
+            "&=" -> expressionEval.operatorAndInplace(address, null, vmDt, value)
+            "^=" -> expressionEval.operatorXorInplace(address, null, vmDt, value)
+            "<<=" -> expressionEval.operatorShiftLeftInplace(address, null, vmDt, value)
+            ">>=" -> expressionEval.operatorShiftRightInplace(address, null, vmDt, value.type in SignedDatatypes, value)
             "%=" -> expressionEval.operatorModuloInplace(address, null, vmDt, value)
             "==" -> expressionEval.operatorEqualsInplace(address, null, vmDt, value)
             "!=" -> expressionEval.operatorNotEqualsInplace(address, null, vmDt, value)
@@ -96,8 +100,6 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
     }
 
     private fun fallbackAssign(origAssign: PtAugmentedAssign): IRCodeChunks {
-        if (codeGen.options.slowCodegenWarnings)
-            codeGen.errors.warn("indirect code for in-place assignment", origAssign.position)
         val value: PtExpression
         if(origAssign.operator in PrefixOperators) {
             value = PtPrefix(origAssign.operator, origAssign.value.type, origAssign.value.position)
@@ -200,8 +202,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             val variable = targetArray.variable.name
             val itemsize = codeGen.program.memsizer.memorySize(targetArray.type)
 
-            if(targetArray.variable.type==DataType.UWORD) {
-                // indexing a pointer var instead of a real array or string
+            if(targetArray.usesPointerVariable) {
                 if(itemsize!=1)
                     throw AssemblyError("non-array var indexing requires bytes dt")
                 if(targetArray.index.type!=DataType.UBYTE)

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

@@ -24,10 +24,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "popw" -> funcPopw(call)
             "push" -> funcPush(call)
             "pushw" -> funcPushw(call)
-            "rsave",
-            "rsavex",
-            "rrestore",
-            "rrestorex" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
+            "rsave", "rrestore" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
             "callfar" -> funcCallfar(call)
             "msb" -> funcMsb(call)
             "lsb" -> funcLsb(call)
@@ -48,10 +45,28 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "rol2" -> funcRolRor(Opcode.ROL, call)
             "ror2" -> funcRolRor(Opcode.ROR, call)
             "prog8_lib_stringcompare" -> funcStringCompare(call)
+            "prog8_lib_square_byte" -> funcSquare(call, IRDataType.BYTE)
+            "prog8_lib_square_word" -> funcSquare(call, IRDataType.WORD)
             else -> throw AssemblyError("missing builtinfunc for ${call.name}")
         }
     }
 
+    private fun funcSquare(call: PtBuiltinFunctionCall, resultType: IRDataType): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val valueTr = exprGen.translateExpression(call.args[0])
+        addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
+        return if(resultType==IRDataType.FLOAT) {
+            val resultFpReg = codeGen.registers.nextFreeFloat()
+            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, fpReg1 = resultFpReg, fpReg2 = valueTr.resultFpReg), null)
+            ExpressionCodeResult(result, resultType, -1, resultFpReg)
+        }
+        else {
+            val resultReg = codeGen.registers.nextFree()
+            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, reg1 = resultReg, reg2 = valueTr.resultReg), null)
+            ExpressionCodeResult(result, resultType, resultReg, -1)
+        }
+    }
+
     private fun funcCallfar(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val bankTr = exprGen.translateExpression(call.args[0])

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

@@ -147,8 +147,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val result = mutableListOf<IRCodeChunkBase>()
         val arrayVarSymbol = arrayIx.variable.name
 
-        if(arrayIx.variable.type==DataType.UWORD) {
-            // indexing a pointer var instead of a real array or string
+        if(arrayIx.usesPointerVariable) {
             if(eltSize!=1)
                 throw AssemblyError("non-array var indexing requires bytes dt")
             if(arrayIx.index.type!=DataType.UBYTE)

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

@@ -29,9 +29,6 @@ class IRCodeGen(
         irSymbolTable = IRSymbolTable(symbolTable)
         val irProg = IRProgram(program.name, irSymbolTable, options, program.encoding)
 
-        if(options.evalStackBaseAddress!=null)
-            throw AssemblyError("IR doesn't use eval-stack")
-
         // collect global variables initializers
         program.allBlocks().forEach {
             val result = mutableListOf<IRCodeChunkBase>()
@@ -292,6 +289,8 @@ class IRCodeGen(
             }
         }
 
+        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(node.position)
+
         return chunks
     }
 
@@ -413,10 +412,17 @@ class IRCodeGen(
                 result += translateNode(choice.statements)
                 addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = endLabel), null)
             } else {
-                val choiceLabel = createLabelName()
-                choices.add(choiceLabel to choice)
-                choice.values.children.map { it as PtNumber }.sortedBy { it.number }.forEach { value ->
-                    addInstr(result, IRInstruction(Opcode.BEQ, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt(), labelSymbol = choiceLabel), null)
+                if(choice.statements.children.isEmpty()) {
+                    // no statements for this choice value, jump to the end immediately
+                    choice.values.children.map { it as PtNumber }.sortedBy { it.number }.forEach { value ->
+                        addInstr(result, IRInstruction(Opcode.BEQ, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt(), labelSymbol = endLabel), null)
+                    }
+                } else {
+                    val choiceLabel = createLabelName()
+                    choices.add(choiceLabel to choice)
+                    choice.values.children.map { it as PtNumber }.sortedBy { it.number }.forEach { value ->
+                        addInstr(result, IRInstruction(Opcode.BEQ, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt(), labelSymbol = choiceLabel), null)
+                    }
                 }
             }
         }
@@ -580,25 +586,23 @@ class IRCodeGen(
             else -> throw AssemblyError("invalid loopvar node type")
         }
         val loopvarDtIr = irType(loopvarDt)
-        val iterable = forLoop.iterable as PtRange
-        val step = iterable.step.number.toInt()
-        val rangeStart = (iterable.from as PtNumber).number.toInt()
-        val rangeEndUntyped = (iterable.to as PtNumber).number.toInt() + step
-        if(step==0)
-            throw AssemblyError("step 0")
-        if(step>0 && rangeEndUntyped<rangeStart || step<0 && rangeEndUntyped>rangeStart)
+        val iterable = (forLoop.iterable as PtRange).toConstantIntegerRange()!!
+        if(iterable.isEmpty())
             throw AssemblyError("empty range")
-        val rangeEndWrapped = if(loopvarDtIr==IRDataType.BYTE) rangeEndUntyped and 255 else rangeEndUntyped and 65535
+        if(iterable.step==0)
+            throw AssemblyError("step 0")
+        val rangeEndExclusiveUntyped = iterable.last + iterable.step
+        val rangeEndExclusiveWrapped = if(loopvarDtIr==IRDataType.BYTE) rangeEndExclusiveUntyped and 255 else rangeEndExclusiveUntyped and 65535
         val result = mutableListOf<IRCodeChunkBase>()
         val chunk = IRCodeChunk(null, null)
-        chunk += IRInstruction(Opcode.LOAD, loopvarDtIr, reg1=indexReg, immediate = rangeStart)
+        chunk += IRInstruction(Opcode.LOAD, loopvarDtIr, reg1=indexReg, immediate = iterable.first)
         chunk += IRInstruction(Opcode.STOREM, loopvarDtIr, reg1=indexReg, labelSymbol=loopvarSymbol)
         result += chunk
         result += labelFirstChunk(translateNode(forLoop.statements), loopLabel)
-        result += addConstMem(loopvarDtIr, null, loopvarSymbol, step)
-        val chunk2 = IRCodeChunk(null, null)
+        val chunk2 = addConstMem(loopvarDtIr, null, loopvarSymbol, iterable.step)
         chunk2 += IRInstruction(Opcode.LOADM, loopvarDtIr, reg1 = indexReg, labelSymbol = loopvarSymbol)
-        chunk2 += IRInstruction(Opcode.BNE, loopvarDtIr, reg1 = indexReg, immediate = rangeEndWrapped, labelSymbol = loopLabel)
+        chunk2 += IRInstruction(Opcode.XOR, loopvarDtIr, reg1 = 999, immediate = 111)
+        chunk2 += IRInstruction(Opcode.BNE, loopvarDtIr, reg1 = indexReg, immediate = rangeEndExclusiveWrapped, labelSymbol = loopLabel)
         result += chunk2
         return result
     }
@@ -1465,7 +1469,19 @@ class IRCodeGen(
                 val fixedIndex = constIntValue(array.index)
                 if(fixedIndex!=null) {
                     val offset = fixedIndex*itemsize
-                    addInstr(result, IRInstruction(operationMem, irDt, labelSymbol="$variable+$offset"), null)
+                    val indexReg = registers.nextFree()
+                    val dataReg = registers.nextFree()
+                    if(array.usesPointerVariable) {
+                        // we don't have an indirect dec/inc so do it via an intermediate register
+                        result += IRCodeChunk(null,null).also {
+                            it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = indexReg, immediate = offset)
+                            it += IRInstruction(Opcode.LOADIX, irDt, reg1 = dataReg, reg2 = indexReg, labelSymbol = variable)
+                            it += IRInstruction(operationRegister, irDt, reg1=dataReg)
+                            it += IRInstruction(Opcode.STOREIX, irDt, reg1 = dataReg, reg2 = indexReg, labelSymbol = variable)
+                        }
+                    } else {
+                        addInstr(result, IRInstruction(operationMem, irDt, labelSymbol = "$variable+$offset"), null)
+                    }
                 } else {
                     val indexTr = expressionEval.translateExpression(array.index)
                     addToResult(result, indexTr, indexTr.resultReg, -1)
@@ -1473,9 +1489,15 @@ class IRCodeGen(
                         result += multiplyByConst(IRDataType.BYTE, indexTr.resultReg, itemsize)
                     result += IRCodeChunk(null, null).also {
                         val incReg = registers.nextFree()
-                        it += IRInstruction(Opcode.LOADX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
-                        it += IRInstruction(operationRegister, irDt, reg1=incReg)
-                        it += IRInstruction(Opcode.STOREX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
+                        if(array.usesPointerVariable) {
+                            it += IRInstruction(Opcode.LOADIX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
+                            it += IRInstruction(operationRegister, irDt, reg1=incReg)
+                            it += IRInstruction(Opcode.STOREIX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
+                        } else {
+                            it += IRInstruction(Opcode.LOADX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
+                            it += IRInstruction(operationRegister, irDt, reg1=incReg)
+                            it += IRInstruction(Opcode.STOREX, irDt, reg1=incReg, reg2=indexTr.resultReg, labelSymbol=variable)
+                        }
                     }
                 }
             } else
@@ -1648,24 +1670,6 @@ class IRCodeGen(
 
     internal fun isOne(expression: PtExpression): Boolean = expression is PtNumber && expression.number==1.0
 
-    fun getReusableTempvar(scope: PtNamedNode, type: DataType): PtIdentifier {
-        val uniqueId = Pair(scope, type).hashCode().toUInt()
-        val tempvarname = "${scope.scopedName}.tempvar_${uniqueId}"
-        val tempvar = PtIdentifier(tempvarname, type, Position.DUMMY)
-        val staticVar = StStaticVariable(
-            tempvarname,
-            type,
-            null,
-            null,
-            null,
-            null,
-            ZeropageWish.DONTCARE,
-            tempvar
-        )
-        irSymbolTable.add(staticVar)
-        return tempvar
-    }
-
     fun makeSyscall(syscall: IMSyscall, params: List<Pair<IRDataType, Int>>, returns: Pair<IRDataType, Int>?, label: String?=null): IRCodeChunk {
         return IRCodeChunk(label, null).also {
             val args = params.map { (dt, reg)->

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

@@ -105,7 +105,10 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
 
         relabelChunks.forEach { (index, label) ->
             val chunk = IRCodeChunk(label, null)
-            chunk.instructions += sub.chunks[index].instructions
+            val subChunk = sub.chunks[index]
+            chunk.instructions += subChunk.instructions
+            if(subChunk is IRCodeChunk)
+                chunk.appendSrcPositions(subChunk.sourceLinesPositions)
             sub.chunks[index] = chunk
         }
         removeChunks.reversed().forEach { index -> sub.chunks.removeAt(index) }
@@ -140,6 +143,8 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                     if(mayJoinCodeChunks(lastChunk, candidate)) {
                         lastChunk.instructions += candidate.instructions
                         lastChunk.next = candidate.next
+                        if(lastChunk is IRCodeChunk)
+                            lastChunk.appendSrcPositions(candidate.sourceLinesPositions)
                     }
                     else
                         chunks += candidate

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

@@ -1,7 +1,7 @@
 package prog8.codegen.intermediate
 
 import prog8.code.core.IErrorReporter
-import prog8.code.core.SourceCode.Companion.libraryFilePrefix
+import prog8.code.core.SourceCode.Companion.LIBRARYFILEPREFIX
 import prog8.intermediate.*
 
 
@@ -50,7 +50,7 @@ class IRUnusedCodeRemover(
         irprog.blocks.forEach { block ->
             block.children.filterIsInstance<IRSubroutine>().reversed().forEach { sub ->
                 if(sub.isEmpty()) {
-                    if(!sub.position.file.startsWith(libraryFilePrefix)) {
+                    if(!sub.position.file.startsWith(LIBRARYFILEPREFIX)) {
                         errors.warn("unused subroutine ${sub.label}", sub.position)
                     }
                     block.children.remove(sub)
@@ -71,7 +71,7 @@ class IRUnusedCodeRemover(
         irprog.blocks.forEach { block ->
             block.children.filterIsInstance<IRAsmSubroutine>().reversed().forEach { sub ->
                 if(sub.isEmpty()) {
-                    if(!sub.position.file.startsWith(libraryFilePrefix)) {
+                    if(!sub.position.file.startsWith(LIBRARYFILEPREFIX)) {
                         errors.warn("unused asmsubroutine ${sub.label}", sub.position)
                     }
                     block.children.remove(sub)

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

@@ -16,7 +16,7 @@ class VmCodeGen: ICodeGeneratorBackend {
         symbolTable: SymbolTable,
         options: CompilationOptions,
         errors: IErrorReporter
-    ): IAssemblyProgram? {
+    ): IAssemblyProgram {
         val irCodeGen = IRCodeGen(program, symbolTable, options, errors)
         val irProgram = irCodeGen.generate()
         return VmAssemblyProgram(irProgram.name, irProgram)

codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt

@@ -1,71 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.IStatementContainer
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.expressions.BinaryExpression
-import prog8.ast.statements.AssignTarget
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.AssignmentOrigin
-import prog8.ast.walk.AstWalker
-import prog8.ast.walk.IAstModification
-import prog8.code.core.AugmentAssignmentOperators
-import prog8.code.core.CompilationOptions
-import prog8.code.core.DataType
-import prog8.code.target.VMTarget
-
-
-class BinExprSplitter(private val program: Program, private val options: CompilationOptions) : AstWalker() {
-
-    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-
-        if(options.compTarget.name == VMTarget.NAME)
-            return noModifications  // don't split expressions when targeting the vm codegen, it handles nested expressions well
-
-        if(assignment.value.inferType(program) istype DataType.FLOAT && !options.optimizeFloatExpressions)
-            return noModifications
-
-        val binExpr = assignment.value as? BinaryExpression
-        if (binExpr != null) {
-
-            if(binExpr.operator in AugmentAssignmentOperators && isSimpleTarget(assignment.target)) {
-                if(assignment.target isSameAs binExpr.right)
-                    return noModifications
-                if(assignment.target isSameAs binExpr.left) {
-                    if(binExpr.right.isSimple)
-                        return noModifications
-                    val leftBx = binExpr.left as? BinaryExpression
-                    if(leftBx!=null && (!leftBx.left.isSimple || !leftBx.right.isSimple))
-                        return noModifications
-                    val rightBx = binExpr.right as? BinaryExpression
-                    if(rightBx!=null && (!rightBx.left.isSimple || !rightBx.right.isSimple))
-                        return noModifications
-                }
-
-                if(binExpr.right.isSimple) {
-                    val firstAssign = Assignment(assignment.target.copy(), binExpr.left, AssignmentOrigin.OPTIMIZER, binExpr.left.position)
-                    val targetExpr = assignment.target.toExpression()
-                    val augExpr = BinaryExpression(targetExpr, binExpr.operator, binExpr.right, binExpr.right.position)
-                    return listOf(
-                        IAstModification.ReplaceNode(binExpr, augExpr, assignment),
-                        IAstModification.InsertBefore(assignment, firstAssign, assignment.parent as IStatementContainer)
-                    )
-                }
-            }
-
-            // Further unraveling of binary expressions is really complicated here and
-            // often results in much bigger code, thereby defeating the purpose a bit.
-            // All in all this should probably be fixed in a better code generation backend
-            // that doesn't require this at all.
-        }
-
-        return noModifications
-    }
-
-    private fun isSimpleTarget(target: AssignTarget) =
-            if (target.identifier!=null || target.memoryAddress!=null)
-                !target.isIOAddress(options.compTarget.machine)
-            else
-                false
-
-}

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -235,6 +235,47 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
             }
         }
 
+        if(rightconst!=null && (expr.operator=="<<" || expr.operator==">>")) {
+            val dt = expr.left.inferType(program)
+            if(dt.isBytes && rightconst.number>=8) {
+                if(dt.istype(DataType.UBYTE)) {
+                    val zeroUB = NumericLiteral(DataType.UBYTE, 0.0, expr.position)
+                    modifications.add(IAstModification.ReplaceNode(expr, zeroUB, parent))
+                } else {
+                    if(leftconst!=null) {
+                        val zeroB = NumericLiteral(DataType.BYTE, 0.0, expr.position)
+                        val minusoneB = NumericLiteral(DataType.BYTE, -1.0, expr.position)
+                        if(leftconst.number<0.0) {
+                            if(expr.operator=="<<")
+                                modifications.add(IAstModification.ReplaceNode(expr, zeroB, parent))
+                            else
+                                modifications.add(IAstModification.ReplaceNode(expr, minusoneB, parent))
+                        } else {
+                            modifications.add(IAstModification.ReplaceNode(expr, zeroB, parent))
+                        }
+                    }
+                }
+            }
+            else if(dt.isWords && rightconst.number>=16) {
+                if(dt.istype(DataType.UWORD)) {
+                    val zeroUW = NumericLiteral(DataType.UWORD, 0.0, expr.position)
+                    modifications.add(IAstModification.ReplaceNode(expr, zeroUW, parent))
+                } else {
+                    if(leftconst!=null) {
+                        val zeroW = NumericLiteral(DataType.WORD, 0.0, expr.position)
+                        val minusoneW = NumericLiteral(DataType.WORD, -1.0, expr.position)
+                        if(leftconst.number<0.0) {
+                            if(expr.operator=="<<")
+                                modifications.add(IAstModification.ReplaceNode(expr, zeroW, parent))
+                            else
+                                modifications.add(IAstModification.ReplaceNode(expr, minusoneW, parent))
+                        } else {
+                            modifications.add(IAstModification.ReplaceNode(expr, zeroW, parent))
+                        }
+                    }
+                }
+            }
+        }
 
         return modifications
     }

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -280,10 +280,16 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     val rangeExpr = decl.value as? RangeExpression
                     if(rangeExpr!=null) {
                         // convert the initializer range expression to an actual array
+                        val constRange = rangeExpr.toConstantIntegerRange()
+                        if(constRange?.isEmpty()==true) {
+                            if(constRange.first>constRange.last && constRange.step>=0)
+                                errors.err("descending range with positive step", decl.value?.position!!)
+                            else if(constRange.first<constRange.last && constRange.step<=0)
+                                errors.err("ascending range with negative step", decl.value?.position!!)
+                        }
                         val declArraySize = decl.arraysize?.constIndex()
                         if(declArraySize!=null && declArraySize!=rangeExpr.size())
                             errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
                         if(constRange!=null) {
                             val eltType = rangeExpr.inferType(program).getOr(DataType.UBYTE)
                             val newValue = if(eltType in ByteDatatypes) {

codeOptimizers/src/prog8/optimizer/Extensions.kt

@@ -65,9 +65,3 @@ fun Program.simplifyExpressions(errors: IErrorReporter, target: ICompilationTarg
     opti.visit(this)
     return opti.applyModifications()
 }
-
-fun Program.splitBinaryExpressions(options: CompilationOptions) : Int {
-    val opti = BinExprSplitter(this, options)
-    opti.visit(this)
-    return opti.applyModifications()
-}

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -111,8 +111,6 @@ class StatementOptimizer(private val program: Program,
         // remove obvious dangling elses (else after a return)
         if(ifElse.elsepart.isNotEmpty() && ifElse.truepart.statements.singleOrNull() is Return) {
             val elsePart = AnonymousScope(ifElse.elsepart.statements, ifElse.elsepart.position)
-            if(options.slowCodegenWarnings)
-                errors.warn("else can be omitted", ifElse.elsepart.position)
             return listOf(
                 IAstModification.ReplaceNode(ifElse.elsepart, AnonymousScope(mutableListOf(), ifElse.elsepart.position), ifElse),
                 IAstModification.InsertAfter(ifElse, elsePart, parent as IStatementContainer)

compiler/build.gradle

@@ -33,7 +33,7 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation project(':codeGenExperimental')
     implementation project(':virtualmachine')
-    implementation "org.antlr:antlr4-runtime:4.13.0"
+    implementation "org.antlr:antlr4-runtime:4.12.0"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.5'

compiler/res/prog8lib/atari/textio.p8

@@ -32,7 +32,7 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
-asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
+asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
     ; ---- fill the character screen with the given fill character and character color.
     ;      (assumes screen and color matrix are at their default addresses)
     ;      TODO
@@ -42,7 +42,7 @@ asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
     }}
 }
 
-asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
+asmsub  clear_screenchars (ubyte character @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	; TODO
@@ -114,10 +114,10 @@ asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A)  {
 }
 
 
-romsub $F2B0 = outchar(ubyte char @ A)
+romsub $F2B0 = outchar(ubyte character @ A)
 romsub $F2Fd = waitkey()
 
-asmsub chrout(ubyte char @ A) {
+asmsub chrout(ubyte character @ A) {
 	%asm {{
 		sta  _tmp_outchar+1
 		txa
@@ -153,10 +153,9 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -164,16 +163,13 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		pla
 		jsr  chrout
 		txa
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -189,16 +185,13 @@ _print_byte_digits
         beq  _ones
         jsr  chrout
 _ones   txa
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		pha
 		cmp  #0
 		bpl  +
@@ -210,10 +203,9 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -222,16 +214,13 @@ asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  conv.ubyte2hex
 		jsr  chrout
 		tya
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -244,12 +233,11 @@ asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  chrout
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -261,7 +249,7 @@ asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -274,10 +262,9 @@ asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -285,17 +272,14 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  chrout
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG
-		rts
++		rts
 	}}
 }
 
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -316,7 +300,7 @@ _allzero
 	}}
 }
 
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -380,7 +364,7 @@ asmsub  getclr  (ubyte col @A, ubyte row @Y) clobbers(Y) -> ubyte @ A {
         }}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+sub  setcc  (ubyte col, ubyte row, ubyte char, ubyte charcolor)  {
 	; ---- set char+color at the given position on the screen
 	; TODO
 	%asm {{
@@ -388,7 +372,7 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
         }}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
+asmsub  plot  (ubyte col @ Y, ubyte row @ A) {
 	; ---- set cursor at specific position
 	; TODO
 	%asm  {{

compiler/res/prog8lib/c128/syslib.p8

@@ -87,7 +87,7 @@ romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc    ; (via 798
 romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
 romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
 romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
+romsub $FFD2 = CHROUT(ubyte character @ A)                           ; (via 806 ($326)) output a character
 romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A, uword @ XY     ; (via 816 ($330)) load from device
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> bool @ Pc, ubyte @ A          ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
@@ -104,34 +104,26 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 ; ---- utilities -----
 
-asmsub STOP2() -> ubyte @A  {
+asmsub STOP2() clobbers(X) -> ubyte @A  {
     ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
     %asm {{
-        txa
-        pha
         jsr  cbm.STOP
         beq  +
-        pla
-        tax
         lda  #0
         rts
-+       pla
-        tax
-        lda  #1
++       lda  #1
         rts
     }}
 }
 
-asmsub RDTIM16() -> uword @AY {
+asmsub RDTIM16() clobbers(X) -> uword @AY {
     ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience
     %asm {{
-        stx  P8ZP_SCRATCH_REG
         jsr  cbm.RDTIM
         pha
         txa
         tay
         pla
-        ldx  P8ZP_SCRATCH_REG
         rts
     }}
 }
@@ -343,7 +335,7 @@ asmsub  init_system()  {
     ; This means that the BASIC, KERNAL and CHARGEN ROMs are banked in,
     ; the VIC, SID and CIA chips are reset, screen is cleared, and the default IRQ is set.
     ; Also a different color scheme is chosen to identify ourselves a little.
-    ; Uppercase charset is activated, and all three registers set to 0, status flags cleared.
+    ; Uppercase charset is activated.
     %asm {{
         sei
         cld
@@ -446,10 +438,6 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
-		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
-		; We assume IRQ handlers don't contain complex expressions taking up more than that.
-		ldx  #32
 		cld
 		rts
 
@@ -774,111 +762,108 @@ cx16 {
     ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
     ; they are simulated on the C128 as well but their location in memory is different
     ; (because there's no room for them in the zeropage)
-    ; $1300-$1bff is unused RAM on C128. We'll use $1a00-$1bff as the lo/hi evalstack.
-    ; the virtual registers are allocated at the bottom of the eval-stack (should be ample space unless
-    ; you're doing insane nesting of expressions...)
-    ; NOTE: the memory location of these registers can change based on the "-esa" compiler option
-    &uword r0  = $1b00
-    &uword r1  = $1b02
-    &uword r2  = $1b04
-    &uword r3  = $1b06
-    &uword r4  = $1b08
-    &uword r5  = $1b0a
-    &uword r6  = $1b0c
-    &uword r7  = $1b0e
-    &uword r8  = $1b10
-    &uword r9  = $1b12
-    &uword r10 = $1b14
-    &uword r11 = $1b16
-    &uword r12 = $1b18
-    &uword r13 = $1b1a
-    &uword r14 = $1b1c
-    &uword r15 = $1b1e
+    ; $1300-$1bff is unused RAM on C128.
+    &uword r0  = $1be0
+    &uword r1  = $1be2
+    &uword r2  = $1be4
+    &uword r3  = $1be6
+    &uword r4  = $1be8
+    &uword r5  = $1bea
+    &uword r6  = $1bec
+    &uword r7  = $1bee
+    &uword r8  = $1bf0
+    &uword r9  = $1bf2
+    &uword r10 = $1bf4
+    &uword r11 = $1bf6
+    &uword r12 = $1bf8
+    &uword r13 = $1bfa
+    &uword r14 = $1bfc
+    &uword r15 = $1bfe
 
-    &word r0s  = $1b00
-    &word r1s  = $1b02
-    &word r2s  = $1b04
-    &word r3s  = $1b06
-    &word r4s  = $1b08
-    &word r5s  = $1b0a
-    &word r6s  = $1b0c
-    &word r7s  = $1b0e
-    &word r8s  = $1b10
-    &word r9s  = $1b12
-    &word r10s = $1b14
-    &word r11s = $1b16
-    &word r12s = $1b18
-    &word r13s = $1b1a
-    &word r14s = $1b1c
-    &word r15s = $1b1e
+    &word r0s  = $1be0
+    &word r1s  = $1be2
+    &word r2s  = $1be4
+    &word r3s  = $1be6
+    &word r4s  = $1be8
+    &word r5s  = $1bea
+    &word r6s  = $1bec
+    &word r7s  = $1bee
+    &word r8s  = $1bf0
+    &word r9s  = $1bf2
+    &word r10s = $1bf4
+    &word r11s = $1bf6
+    &word r12s = $1bf8
+    &word r13s = $1bfa
+    &word r14s = $1bfc
+    &word r15s = $1bfe
 
-    &ubyte r0L  = $1b00
-    &ubyte r1L  = $1b02
-    &ubyte r2L  = $1b04
-    &ubyte r3L  = $1b06
-    &ubyte r4L  = $1b08
-    &ubyte r5L  = $1b0a
-    &ubyte r6L  = $1b0c
-    &ubyte r7L  = $1b0e
-    &ubyte r8L  = $1b10
-    &ubyte r9L  = $1b12
-    &ubyte r10L = $1b14
-    &ubyte r11L = $1b16
-    &ubyte r12L = $1b18
-    &ubyte r13L = $1b1a
-    &ubyte r14L = $1b1c
-    &ubyte r15L = $1b1e
+    &ubyte r0L  = $1be0
+    &ubyte r1L  = $1be2
+    &ubyte r2L  = $1be4
+    &ubyte r3L  = $1be6
+    &ubyte r4L  = $1be8
+    &ubyte r5L  = $1bea
+    &ubyte r6L  = $1bec
+    &ubyte r7L  = $1bee
+    &ubyte r8L  = $1bf0
+    &ubyte r9L  = $1bf2
+    &ubyte r10L = $1bf4
+    &ubyte r11L = $1bf6
+    &ubyte r12L = $1bf8
+    &ubyte r13L = $1bfa
+    &ubyte r14L = $1bfc
+    &ubyte r15L = $1bfe
 
-    &ubyte r0H  = $1b01
-    &ubyte r1H  = $1b03
-    &ubyte r2H  = $1b05
-    &ubyte r3H  = $1b07
-    &ubyte r4H  = $1b09
-    &ubyte r5H  = $1b0b
-    &ubyte r6H  = $1b0d
-    &ubyte r7H  = $1b0f
-    &ubyte r8H  = $1b11
-    &ubyte r9H  = $1b13
-    &ubyte r10H = $1b15
-    &ubyte r11H = $1b17
-    &ubyte r12H = $1b19
-    &ubyte r13H = $1b1b
-    &ubyte r14H = $1b1d
-    &ubyte r15H = $1b1f
+    &ubyte r0H  = $1be1
+    &ubyte r1H  = $1be3
+    &ubyte r2H  = $1be5
+    &ubyte r3H  = $1be7
+    &ubyte r4H  = $1be9
+    &ubyte r5H  = $1beb
+    &ubyte r6H  = $1bed
+    &ubyte r7H  = $1bef
+    &ubyte r8H  = $1bf1
+    &ubyte r9H  = $1bf3
+    &ubyte r10H = $1bf5
+    &ubyte r11H = $1bf7
+    &ubyte r12H = $1bf9
+    &ubyte r13H = $1bfb
+    &ubyte r14H = $1bfd
+    &ubyte r15H = $1bff
 
-    &byte r0sL  = $1b00
-    &byte r1sL  = $1b02
-    &byte r2sL  = $1b04
-    &byte r3sL  = $1b06
-    &byte r4sL  = $1b08
-    &byte r5sL  = $1b0a
-    &byte r6sL  = $1b0c
-    &byte r7sL  = $1b0e
-    &byte r8sL  = $1b10
-    &byte r9sL  = $1b12
-    &byte r10sL = $1b14
-    &byte r11sL = $1b16
-    &byte r12sL = $1b18
-    &byte r13sL = $1b1a
-    &byte r14sL = $1b1c
-    &byte r15sL = $1b1e
+    &byte r0sL  = $1be0
+    &byte r1sL  = $1be2
+    &byte r2sL  = $1be4
+    &byte r3sL  = $1be6
+    &byte r4sL  = $1be8
+    &byte r5sL  = $1bea
+    &byte r6sL  = $1bec
+    &byte r7sL  = $1bee
+    &byte r8sL  = $1bf0
+    &byte r9sL  = $1bf2
+    &byte r10sL = $1bf4
+    &byte r11sL = $1bf6
+    &byte r12sL = $1bf8
+    &byte r13sL = $1bfa
+    &byte r14sL = $1bfc
+    &byte r15sL = $1bfe
 
-    &byte r0sH  = $1b01
-    &byte r1sH  = $1b03
-    &byte r2sH  = $1b05
-    &byte r3sH  = $1b07
-    &byte r4sH  = $1b09
-    &byte r5sH  = $1b0b
-    &byte r6sH  = $1b0d
-    &byte r7sH  = $1b0f
-    &byte r8sH  = $1b11
-    &byte r9sH  = $1b13
-    &byte r10sH = $1b15
-    &byte r11sH = $1b17
-    &byte r12sH = $1b19
-    &byte r13sH = $1b1b
-    &byte r14sH = $1b1d
-    &byte r15sH = $1b1f
+    &byte r0sH  = $1be1
+    &byte r1sH  = $1be3
+    &byte r2sH  = $1be5
+    &byte r3sH  = $1be7
+    &byte r4sH  = $1be9
+    &byte r5sH  = $1beb
+    &byte r6sH  = $1bed
+    &byte r7sH  = $1bef
+    &byte r8sH  = $1bf1
+    &byte r9sH  = $1bf3
+    &byte r10sH = $1bf5
+    &byte r11sH = $1bf7
+    &byte r12sH = $1bf9
+    &byte r13sH = $1bfb
+    &byte r14sH = $1bfd
+    &byte r15sH = $1bff
 
     asmsub save_virtual_registers() clobbers(A,Y) {
         %asm {{

compiler/res/prog8lib/c128/textio.p8

@@ -1,4 +1,4 @@
-; Prog8 definitions for the Text I/O and Screen routines for the Commodore-64
+; Prog8 definitions for the Text I/O and Screen routines for the Commodore-128
 
 %import syslib
 %import conv
@@ -97,13 +97,12 @@ sub uppercase() {
     c128.VM1 &= ~2
 }
 
-asmsub  scroll_left  (bool alsocolors @ Pc) clobbers(A, Y)  {
+asmsub  scroll_left  (bool alsocolors @ Pc) clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -133,17 +132,15 @@ _scroll_screen  ; scroll only the screen memory
 		dey
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_right  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_right  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -169,17 +166,15 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_up  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_up  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -205,17 +200,15 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -241,7 +234,6 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
@@ -266,10 +258,9 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -277,16 +268,13 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		pla
 		jsr  cbm.CHROUT
 		txa
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -302,16 +290,13 @@ _print_byte_digits
         beq  _ones
         jsr  cbm.CHROUT
 _ones   txa
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		pha
 		cmp  #0
 		bpl  +
@@ -323,10 +308,9 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -335,16 +319,13 @@ asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  conv.ubyte2hex
 		jsr  cbm.CHROUT
 		tya
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -357,12 +338,11 @@ asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  cbm.CHROUT
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -374,7 +354,7 @@ asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -387,10 +367,9 @@ asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -398,17 +377,14 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  cbm.CHROUT
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG
-		rts
++		rts
 	}}
 }
 
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -429,7 +405,7 @@ _allzero
 	}}
 }
 
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -490,7 +466,7 @@ asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)
 _mod		sta  $ffff		; modified
 		rts
 
-_screenrows	.word  $0400 + range(0, 1000, 40)
+_screenrows	.word  cbm.Screen + range(0, 1000, 40)
 	}}
 }
 
@@ -557,7 +533,7 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor)  {
 	; ---- set char+color at the given position on the screen
 	%asm {{
 		lda  row
@@ -569,13 +545,13 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
 		sta  _colormod+2
 		lda  setchr._screenrows,y
 		clc
-		adc  column
+		adc  col
 		sta  _charmod+1
 		sta  _colormod+1
 		bcc  +
 		inc  _charmod+2
 		inc  _colormod+2
-+		lda  char
++		lda  character
 _charmod	sta  $ffff		; modified
 		lda  charcolor
 _colormod	sta  $ffff		; modified
@@ -583,15 +559,10 @@ _colormod	sta  $ffff		; modified
 	}}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
-	; ---- safe wrapper around PLOT kernal routine, to save the X register.
+asmsub  plot  (ubyte col @ Y, ubyte row @ X) {
 	%asm  {{
-		stx  P8ZP_SCRATCH_REG
-		tax
 		clc
-		jsr  cbm.PLOT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.PLOT
 	}}
 }
 

compiler/res/prog8lib/c64/floats.asm

@@ -5,13 +5,11 @@ FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
 FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
 
 
-floats_store_reg	.byte  0		; temp storage
 floats_temp_var         .byte  0,0,0,0,0        ; temporary storage for a float
 
 ub2float	.proc
 		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers A, X, Y
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  P8ZP_SCRATCH_B1
@@ -19,15 +17,12 @@ ub2float	.proc
 		jsr  GIVAYF
 _fac_to_mem	ldx  P8ZP_SCRATCH_W2
 		ldy  P8ZP_SCRATCH_W2+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  MOVMF
 		.pend
 
 b2float		.proc
 		; -- convert byte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers A, X, Y
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		lda  P8ZP_SCRATCH_B1
@@ -37,7 +32,7 @@ b2float		.proc
 
 uw2float	.proc
 		; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		lda  P8ZP_SCRATCH_W1
@@ -48,7 +43,7 @@ uw2float	.proc
 
 w2float		.proc
 		; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  P8ZP_SCRATCH_W1
@@ -60,7 +55,7 @@ w2float		.proc
 
 cast_from_uw	.proc
 		; -- uword in A/Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		jsr  GIVUAYFAY
 		jmp  ub2float._fac_to_mem
 		.pend
@@ -68,7 +63,7 @@ cast_from_uw	.proc
 
 cast_from_w	.proc
 		; -- word in A/Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		jsr  GIVAYFAY
 		jmp  ub2float._fac_to_mem
 		.pend
@@ -76,7 +71,7 @@ cast_from_w	.proc
 
 cast_from_ub	.proc
 		; -- ubyte in Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		jsr  FREADUY
 		jmp  ub2float._fac_to_mem
 		.pend
@@ -84,169 +79,41 @@ cast_from_ub	.proc
 
 cast_from_b	.proc
 		; -- byte in A into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		jsr  FREADSA
 		jmp  ub2float._fac_to_mem
 		.pend
 
 cast_as_uw_into_ya	.proc               ; also used for float 2 ub
 		; -- cast float at A/Y to uword into Y/A
+		;    clobbers X
 		jsr  MOVFM
 		jmp  cast_FAC1_as_uw_into_ya
 		.pend
 
 cast_as_w_into_ay	.proc               ; also used for float 2 b
 		; -- cast float at A/Y to word into A/Y
+		;    clobbers X
 		jsr  MOVFM
 		jmp  cast_FAC1_as_w_into_ay
 		.pend
 
 cast_FAC1_as_uw_into_ya	.proc               ; also used for float 2 ub
 		; -- cast fac1 to uword into Y/A
-		stx  P8ZP_SCRATCH_REG
-		jsr  GETADR     ; into Y/A
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		;    clobbers X
+		jmp  GETADR     ; into Y/A
 		.pend
 
 cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
 		; -- cast fac1 to word into A/Y
-		stx  P8ZP_SCRATCH_REG
+		;    clobbers X
 		jsr  AYINT
 		ldy  floats.AYINT_facmo
 		lda  floats.AYINT_facmo+1
-		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
 
 
-stack_b2float	.proc
-		; -- b2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  FREADSA
-		jmp  push_fac1._internal
-		.pend
-
-stack_w2float	.proc
-		; -- w2float operating on the stack
-		inx
-		ldy  P8ESTACK_LO,x
-		lda  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_ub2float	.proc
-		; -- ub2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		tay
-		lda  #0
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_uw2float	.proc
-		; -- uw2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVUAYFAY
-		jmp  push_fac1._internal
-		.pend
-
-stack_float2w	.proc               ; also used for float2b
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  AYINT
-		ldx  P8ZP_SCRATCH_REG
-		lda  floats.AYINT_facmo
-		sta  P8ESTACK_HI,x
-		lda  floats.AYINT_facmo+1
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-stack_float2uw	.proc               ; also used for float2ub
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  GETADR
-		ldx  P8ZP_SCRATCH_REG
-		sta  P8ESTACK_HI,x
-		tya
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-push_float	.proc
-		; ---- push mflpt5 in A/Y onto stack
-		; (taking 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-pop_float	.proc
-		; ---- pops mflpt5 from stack to memory A/Y
-		; (frees 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #4
-		inx
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		rts
-		.pend
-
-pop_float_fac1	.proc
-		; -- pops float from stack into FAC1
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jmp  MOVFM
-		.pend
-
 copy_float	.proc
 		; -- copies the 5 bytes of the mflt value pointed to by P8ZP_SCRATCH_W1,
 		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
@@ -272,25 +139,23 @@ copy_float	.proc
 
 inc_var_f	.proc
 		; -- add 1 to float pointed to by A/Y
+		;    clobbers X
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG
 		jsr  MOVFM
 		lda  #<FL_ONE_const
 		ldy  #>FL_ONE_const
 		jsr  FADD
 		ldx  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  MOVMF
 		.pend
 
 dec_var_f	.proc
 		; -- subtract 1 from float pointed to by A/Y
+		;    clobbers X
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG
 		lda  #<FL_ONE_const
 		ldy  #>FL_ONE_const
 		jsr  MOVFM
@@ -299,23 +164,7 @@ dec_var_f	.proc
 		jsr  FSUB
 		ldx  P8ZP_SCRATCH_W1
 		ldy  P8ZP_SCRATCH_W1+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-
-pop_2_floats_f2_in_fac1	.proc
-		; -- pop 2 floats from stack, load the second one in FAC1 as well
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jmp  MOVFM
+		jmp  MOVMF
 		.pend
 
 
@@ -323,71 +172,9 @@ fmath_float1	.byte 0,0,0,0,0	; storage for a mflpt5 value
 fmath_float2	.byte 0,0,0,0,0	; storage for a mflpt5 value
 
 
-push_fac1	.proc
-		; -- push the float in FAC1 onto the stack
-		stx  P8ZP_SCRATCH_REG
-_internal	ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		ldx  P8ZP_SCRATCH_REG
-		jmp  push_float
-		.pend
-
-div_f		.proc
-		; -- push f1/f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FDIV
-		jmp  push_fac1._internal
-		.pend
-
-add_f		.proc
-		; -- push f1+f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FADD
-		jmp  push_fac1._internal
-		.pend
-
-sub_f		.proc
-		; -- push f1-f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FSUB
-		jmp  push_fac1._internal
-		.pend
-
-mul_f		.proc
-		; -- push f1*f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FMULT
-		jmp  push_fac1._internal
-		.pend
-
-neg_f		.proc
-		; -- toggle the sign bit on the stack
-		lda  P8ESTACK_HI+3,x
-		eor  #$80
-		sta  P8ESTACK_HI+3,x
-		rts
-		.pend
-
 var_fac1_less_f	.proc
-		; -- is the float in FAC1 < the variable AY?
-		stx  P8ZP_SCRATCH_REG
+		; -- is the float in FAC1 < the variable AY? Result in A. Clobbers X.
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #255
 		beq  +
 		lda  #0
@@ -397,10 +184,8 @@ var_fac1_less_f	.proc
 		.pend
 
 var_fac1_lesseq_f	.proc
-		; -- is the float in FAC1 <= the variable AY?
-		stx  P8ZP_SCRATCH_REG
+		; -- is the float in FAC1 <= the variable AY?  Result in A. Clobbers X.
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #0
 		beq  +
 		cmp  #255
@@ -412,10 +197,8 @@ var_fac1_lesseq_f	.proc
 		.pend
 
 var_fac1_greater_f	.proc
-		; -- is the float in FAC1 > the variable AY?
-		stx  P8ZP_SCRATCH_REG
+		; -- is the float in FAC1 > the variable AY?  Result in A. Clobbers X.
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #1
 		beq  +
 		lda  #0
@@ -425,10 +208,8 @@ var_fac1_greater_f	.proc
 		.pend
 
 var_fac1_greatereq_f	.proc
-		; -- is the float in FAC1 >= the variable AY?
-		stx  P8ZP_SCRATCH_REG
+		; -- is the float in FAC1 >= the variable AY?  Result in A. Clobbers X.
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #0
 		beq  +
 		cmp  #1
@@ -439,17 +220,23 @@ var_fac1_greatereq_f	.proc
 		rts
 		.pend
 
+var_fac1_equal_f	.proc
+		; -- are the floats numbers in FAC1 and the variable AY *not* identical?   Result in A. Clobbers X.
+		jsr  FCOMP
+		and  #1
+		eor  #1
+		rts
+		.pend
+
 var_fac1_notequal_f	.proc
-		; -- are the floats numbers in FAC1 and the variable AY *not* identical?
-		stx  P8ZP_SCRATCH_REG
+		; -- are the floats numbers in FAC1 and the variable AY *not* identical?   Result in A. Clobbers X.
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		and  #1
 		rts
 		.pend
 
 vars_equal_f	.proc
-		; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical?
+		; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical?  Result in A
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
@@ -478,51 +265,13 @@ _false		lda  #0
 		rts
 		.pend
 
-equal_f		.proc
-		; -- are the two mflpt5 numbers on the stack identical?
-		inx
-		inx
-		inx
-		inx
-		lda  P8ESTACK_LO-3,x
-		cmp  P8ESTACK_LO,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-2,x
-		cmp  P8ESTACK_LO+1,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-1,x
-		cmp  P8ESTACK_LO+2,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-2,x
-		cmp  P8ESTACK_HI+1,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-1,x
-		cmp  P8ESTACK_HI+2,x
-		bne  _equals_false
-_equals_true	lda  #1
-_equals_store	inx
-		sta  P8ESTACK_LO+1,x
-		rts
-_equals_false	lda  #0
-		beq  _equals_store
-		.pend
-
-notequal_f	.proc
-		; -- are the two mflpt5 numbers on the stack different?
-		jsr  equal_f
-		eor  #1		; invert the result
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
 
 vars_less_f	.proc
-		; -- is float in AY < float in P8ZP_SCRATCH_W2 ?
+		; -- is float in AY < float in P8ZP_SCRATCH_W2 ?   Result in A. Clobbers X.
 		jsr  MOVFM
 		lda  P8ZP_SCRATCH_W2
 		ldy  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #255
 		bne  +
 		lda  #1
@@ -532,13 +281,11 @@ vars_less_f	.proc
 		.pend
 
 vars_lesseq_f	.proc
-		; -- is float in AY <= float in P8ZP_SCRATCH_W2 ?
+		; -- is float in AY <= float in P8ZP_SCRATCH_W2 ?  Result in A. Clobbers X.
 		jsr  MOVFM
 		lda  P8ZP_SCRATCH_W2
 		ldy  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG
 		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
 		cmp  #255
 		bne  +
 -		lda  #1
@@ -550,7 +297,7 @@ vars_lesseq_f	.proc
 		.pend
 
 less_f		.proc
-		; -- is f1 < f2?
+		; -- is f1 < f2?    Result in A. Clobbers X.
 		jsr  compare_floats
 		cmp  #255
 		beq  compare_floats._return_true
@@ -559,7 +306,7 @@ less_f		.proc
 
 
 lesseq_f	.proc
-		; -- is f1 <= f2?
+		; -- is f1 <= f2?  Result in A. Clobbers X.
 		jsr  compare_floats
 		cmp  #255
 		beq  compare_floats._return_true
@@ -569,7 +316,7 @@ lesseq_f	.proc
 		.pend
 
 greater_f	.proc
-		; -- is f1 > f2?
+		; -- is f1 > f2?  Result in A. Clobbers X.
 		jsr  compare_floats
 		cmp  #1
 		beq  compare_floats._return_true
@@ -577,7 +324,7 @@ greater_f	.proc
 		.pend
 
 greatereq_f	.proc
-		; -- is f1 >= f2?
+		; -- is f1 >= f2?  Result in A. Clobbers X.
 		jsr  compare_floats
 		cmp  #1
 		beq  compare_floats._return_true
@@ -586,32 +333,9 @@ greatereq_f	.proc
 		bne  compare_floats._return_false
 		.pend
 
-compare_floats	.proc
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVFM		; fac1 = flt1
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP		; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1<flt2)
-		ldx  P8ZP_SCRATCH_REG
-		rts
-_return_false	lda  #0
-_return_result  sta  P8ESTACK_LO,x
-		dex
-		rts
-_return_true	lda  #1
-		bne  _return_result
-		.pend
-
 set_array_float_from_fac1	.proc
 		; -- set the float in FAC1 in the array (index in A, array in P8ZP_SCRATCH_W1)
+		;    clobbers X
 		sta  P8ZP_SCRATCH_B1
 		asl  a
 		asl  a
@@ -622,11 +346,8 @@ set_array_float_from_fac1	.proc
 		adc  P8ZP_SCRATCH_W1
 		bcc  +
 		iny
-+		stx  floats_store_reg
-		tax
-		jsr  MOVMF
-		ldx  floats_store_reg
-		rts
++		tax
+		jmp  MOVMF
 		.pend
 
 
@@ -669,54 +390,59 @@ set_array_float		.proc
 		.pend
 
 
-equal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  _true
-		bne  _false
-_true		lda  #1
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-_false		lda  #0
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
+pushFAC1    .proc
+	;-- push floating point in FAC onto the cpu stack
+	; save return address
+	pla
+	sta  P8ZP_SCRATCH_W2
+	pla
+	sta  P8ZP_SCRATCH_W2+1
+	ldx  #<floats.floats_temp_var
+	ldy  #>floats.floats_temp_var
+	jsr  floats.MOVMF
+	lda  floats.floats_temp_var
+	pha
+	lda  floats.floats_temp_var+1
+	pha
+	lda  floats.floats_temp_var+2
+	pha
+	lda  floats.floats_temp_var+3
+	pha
+	lda  floats.floats_temp_var+4
+	pha
+	; re-push return address
+	lda  P8ZP_SCRATCH_W2+1
+	pha
+	lda  P8ZP_SCRATCH_W2
+	pha
+	rts
+	.pend
 
-notequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bne  equal_zero._true
-		beq  equal_zero._false
-		.pend
+popFAC1 .proc
+	; -- pop floating point value from cpu stack into FAC1
+	; save return address
+	pla
+	sta  P8ZP_SCRATCH_W2
+	pla
+	sta  P8ZP_SCRATCH_W2+1
+	pla
+	sta  floats.floats_temp_var+4
+	pla
+	sta  floats.floats_temp_var+3
+	pla
+	sta  floats.floats_temp_var+2
+	pla
+	sta  floats.floats_temp_var+1
+	pla
+	sta  floats.floats_temp_var
+	lda  #<floats.floats_temp_var
+	ldy  #>floats.floats_temp_var
+	jsr  floats.MOVFM
+	; re-push return address
+	lda  P8ZP_SCRATCH_W2+1
+	pha
+	lda  P8ZP_SCRATCH_W2
+	pha
+	rts
+	.pend
 
-greater_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  equal_zero._false
-		bpl  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-less_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bmi  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-greaterequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		bpl  equal_zero._true
-		jmp  equal_zero._false
-		.pend
-
-lessequal_zero	.proc
-		jsr  floats.pop_float_fac1
-		jsr  floats.SIGN
-		beq  equal_zero._true
-		bmi  equal_zero._true
-		jmp  equal_zero._false
-		.pend

compiler/res/prog8lib/c64/floats.p8

@@ -46,7 +46,7 @@ romsub $b391 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
 romsub $b3a2 = FREADUY(ubyte value @ Y) clobbers(A,X,Y)     ; 8 bit unsigned Y -> float in fac1
 romsub $bc3c = FREADSA(byte value @ A) clobbers(A,X,Y)      ; 8 bit signed A -> float in fac1
-romsub $b7b5 = FREADSTR(ubyte length @ A) clobbers(A,X,Y)   ; str -> fac1, $22/23 must point to string, A=string length
+romsub $b7b5 = FREADSTR(ubyte length @ A) clobbers(A,X,Y)   ; str -> fac1, $22/23 must point to string, A=string length.  Also see parse_f()
 romsub $aabc = FPRINTLN() clobbers(A,X,Y)                   ; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
 romsub $bddd = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY ($0100)
 
@@ -159,12 +159,19 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 
 sub rndf() -> float {
     %asm {{
-        stx  P8ZP_SCRATCH_REG
         lda  #1
         jsr  FREADSA
-        jsr  RND		; rng into fac1
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  RND		; rng into fac1
+    }}
+}
+
+asmsub parse_f(str value @AY) -> float @FAC1 {
+    %asm {{
+        sta  $22
+        sty  $23
+        jsr  prog8_lib.strlen
+        tya
+        jmp  FREADSTR
     }}
 }
 

compiler/res/prog8lib/c64/floats_funcs.asm

@@ -1,13 +1,6 @@
 ; --- floating point builtin functions
 
 
-func_sign_f_stack	.proc
-		jsr  func_sign_f_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_f_into_A	.proc
 		jsr  MOVFM
 		jmp  SIGN
@@ -146,17 +139,11 @@ func_all_f_stack	.proc
 		.pend
 
 func_abs_f_into_FAC1    .proc
-        stx  P8ZP_SCRATCH_REG
         jsr  MOVFM
-        jsr  ABS
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  ABS
 	.pend
 
 func_sqrt_into_FAC1     .proc
-        stx  P8ZP_SCRATCH_REG
         jsr  MOVFM
-        jsr  SQR
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  SQR
 	.pend

compiler/res/prog8lib/c64/graphics.p8

@@ -127,46 +127,46 @@ graphics {
         }
     }
 
-    sub rect(uword x, ubyte y, uword width, ubyte height) {
+    sub rect(uword xx, ubyte yy, uword width, ubyte height) {
         if width==0 or height==0
             return
-        horizontal_line(x, y, width)
+        horizontal_line(xx, yy, width)
         if height==1
             return
-        horizontal_line(x, y+height-1, width)
-        vertical_line(x, y+1, height-2)
+        horizontal_line(xx, yy+height-1, width)
+        vertical_line(xx, yy+1, height-2)
         if width==1
             return
-        vertical_line(x+width-1, y+1, height-2)
+        vertical_line(xx+width-1, yy+1, height-2)
     }
 
-    sub fillrect(uword x, ubyte y, uword width, ubyte height) {
+    sub fillrect(uword xx, ubyte yy, uword width, ubyte height) {
         if width==0
             return
         repeat height {
-            horizontal_line(x, y, width)
-            y++
+            horizontal_line(xx, yy, width)
+            yy++
         }
     }
 
-    sub horizontal_line(uword x, ubyte y, uword length) {
+    sub horizontal_line(uword xx, ubyte yy, uword length) {
         if length<8 {
-            internal_plotx=x
+            internal_plotx=xx
             repeat lsb(length) {
-                internal_plot(y)
+                internal_plot(yy)
                 internal_plotx++
             }
             return
         }
 
-        ubyte separate_pixels = lsb(x) & 7
-        uword addr = get_y_lookup(y) + (x&$fff8)
+        ubyte separate_pixels = lsb(xx) & 7
+        uword pixaddr = get_y_lookup(yy) + (xx&$fff8)
 
         if separate_pixels {
             %asm {{
-                lda  addr
+                lda  pixaddr
                 sta  P8ZP_SCRATCH_W1
-                lda  addr+1
+                lda  pixaddr+1
                 sta  P8ZP_SCRATCH_W1+1
                 ldy  separate_pixels
                 lda  hline_filled_right,y
@@ -175,7 +175,7 @@ graphics {
                 ora  (P8ZP_SCRATCH_W1),y
                 sta  (P8ZP_SCRATCH_W1),y
             }}
-            addr += 8
+            pixaddr += 8
             length += separate_pixels
             length -= 8
         }
@@ -185,16 +185,15 @@ graphics {
                 lda  length
                 and  #7
                 sta  separate_pixels
-                stx  P8ZP_SCRATCH_REG
                 lsr  length+1
                 ror  length
                 lsr  length+1
                 ror  length
                 lsr  length+1
                 ror  length
-                lda  addr
+                lda  pixaddr
                 sta  _modified+1
-                lda  addr+1
+                lda  pixaddr+1
                 sta  _modified+2
                 lda  length
                 ora  length+1
@@ -210,8 +209,7 @@ _modified       stx  $ffff      ; modified
                 inc  _modified+2
 +               dey
                 bne  _modified
-_zero           ldx  P8ZP_SCRATCH_REG
-
+_zero
                 ldy  separate_pixels
                 beq  hline_zero2
                 lda  _modified+1
@@ -229,11 +227,11 @@ hline_zero2
         }
     }
 
-    sub vertical_line(uword x, ubyte y, ubyte height) {
-        internal_plotx = x
+    sub vertical_line(uword xx, ubyte yy, ubyte height) {
+        internal_plotx = xx
         repeat height {
-            internal_plot(y)
-            y++
+            internal_plot(yy)
+            yy++
         }
     }
 
@@ -302,8 +300,8 @@ hline_zero2
 ; here is the non-asm code for the plot routine below:
 ;    sub plot_nonasm(uword px, ubyte py) {
 ;        ubyte[] ormask = [128, 64, 32, 16, 8, 4, 2, 1]
-;        uword addr = BITMAP_ADDRESS + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
-;        @(addr) |= ormask[lsb(px) & 7]
+;        uword pixaddr = BITMAP_ADDRESS + 320*(py>>3) + (py & 7) + (px & %0000000111111000)
+;        @(pixaddr) |= ormask[lsb(px) & 7]
 ;    }
 
     inline asmsub  plot(uword plotx @XY, ubyte ploty @A) clobbers (A, X, Y) {
@@ -362,7 +360,7 @@ _y_lookup_hi    .byte  >_plot_y_values
         }}
     }
 
-    asmsub get_y_lookup(ubyte y @Y) -> uword @AY {
+    asmsub get_y_lookup(ubyte yy @Y) -> uword @AY {
         %asm {{
             lda  internal_plot._y_lookup_lo,y
             pha

compiler/res/prog8lib/c64/syslib.p8

@@ -91,7 +91,7 @@ romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc    ; (via 798
 romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
 romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
 romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
+romsub $FFD2 = CHROUT(ubyte character @ A)                      ; (via 806 ($326)) output a character
 romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A, uword @ XY     ; (via 816 ($330)) load from device
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> bool @ Pc, ubyte @ A          ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
@@ -104,34 +104,26 @@ romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of
 romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
-asmsub STOP2() -> ubyte @A  {
+asmsub STOP2() clobbers(X) -> ubyte @A  {
     ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
     %asm {{
-        txa
-        pha
         jsr  cbm.STOP
         beq  +
-        pla
-        tax
         lda  #0
         rts
-+       pla
-        tax
-        lda  #1
++       lda  #1
         rts
     }}
 }
 
-asmsub RDTIM16() -> uword @AY {
+asmsub RDTIM16() clobbers(X) -> uword @AY {
     ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience
     %asm {{
-        stx  P8ZP_SCRATCH_REG
         jsr  cbm.RDTIM
         pha
         txa
         tay
         pla
-        ldx  P8ZP_SCRATCH_REG
         rts
     }}
 }
@@ -308,7 +300,7 @@ asmsub  init_system()  {
     ; This means that the BASIC, KERNAL and CHARGEN ROMs are banked in,
     ; the VIC, SID and CIA chips are reset, screen is cleared, and the default IRQ is set.
     ; Also a different color scheme is chosen to identify ourselves a little.
-    ; Uppercase charset is activated, and all three registers set to 0, status flags cleared.
+    ; Uppercase charset is activated.
     %asm {{
         sei
         cld
@@ -413,10 +405,6 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
-		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
-		; We assume IRQ handlers don't contain complex expressions taking up more than that.
-		ldx  #32
 		cld
 		rts
 
@@ -742,111 +730,110 @@ cx16 {
 
     ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
     ; they are simulated on the C64 as well but their location in memory is different
-    ; (because there's no room for them in the zeropage)
-    ; they are allocated at the bottom of the eval-stack (should be ample space unless
-    ; you're doing insane nesting of expressions...)
-    ; NOTE: the memory location of these registers can change based on the "-esa" compiler option
-    &uword r0  = $cf00
-    &uword r1  = $cf02
-    &uword r2  = $cf04
-    &uword r3  = $cf06
-    &uword r4  = $cf08
-    &uword r5  = $cf0a
-    &uword r6  = $cf0c
-    &uword r7  = $cf0e
-    &uword r8  = $cf10
-    &uword r9  = $cf12
-    &uword r10 = $cf14
-    &uword r11 = $cf16
-    &uword r12 = $cf18
-    &uword r13 = $cf1a
-    &uword r14 = $cf1c
-    &uword r15 = $cf1e
+    ; (because there's no room for them in the zeropage in the default configuration)
+    ; Note that when using ZP options that free up more of the zeropage (such as %zeropage kernalsafe)
+    ; there might be enough space to put them there after all, and the compiler will change these addresses!
+    &uword r0  = $cfe0
+    &uword r1  = $cfe2
+    &uword r2  = $cfe4
+    &uword r3  = $cfe6
+    &uword r4  = $cfe8
+    &uword r5  = $cfea
+    &uword r6  = $cfec
+    &uword r7  = $cfee
+    &uword r8  = $cff0
+    &uword r9  = $cff2
+    &uword r10 = $cff4
+    &uword r11 = $cff6
+    &uword r12 = $cff8
+    &uword r13 = $cffa
+    &uword r14 = $cffc
+    &uword r15 = $cffe
 
-    &word r0s  = $cf00
-    &word r1s  = $cf02
-    &word r2s  = $cf04
-    &word r3s  = $cf06
-    &word r4s  = $cf08
-    &word r5s  = $cf0a
-    &word r6s  = $cf0c
-    &word r7s  = $cf0e
-    &word r8s  = $cf10
-    &word r9s  = $cf12
-    &word r10s = $cf14
-    &word r11s = $cf16
-    &word r12s = $cf18
-    &word r13s = $cf1a
-    &word r14s = $cf1c
-    &word r15s = $cf1e
+    &word r0s  = $cfe0
+    &word r1s  = $cfe2
+    &word r2s  = $cfe4
+    &word r3s  = $cfe6
+    &word r4s  = $cfe8
+    &word r5s  = $cfea
+    &word r6s  = $cfec
+    &word r7s  = $cfee
+    &word r8s  = $cff0
+    &word r9s  = $cff2
+    &word r10s = $cff4
+    &word r11s = $cff6
+    &word r12s = $cff8
+    &word r13s = $cffa
+    &word r14s = $cffc
+    &word r15s = $cffe
 
-    &ubyte r0L  = $cf00
-    &ubyte r1L  = $cf02
-    &ubyte r2L  = $cf04
-    &ubyte r3L  = $cf06
-    &ubyte r4L  = $cf08
-    &ubyte r5L  = $cf0a
-    &ubyte r6L  = $cf0c
-    &ubyte r7L  = $cf0e
-    &ubyte r8L  = $cf10
-    &ubyte r9L  = $cf12
-    &ubyte r10L = $cf14
-    &ubyte r11L = $cf16
-    &ubyte r12L = $cf18
-    &ubyte r13L = $cf1a
-    &ubyte r14L = $cf1c
-    &ubyte r15L = $cf1e
+    &ubyte r0L  = $cfe0
+    &ubyte r1L  = $cfe2
+    &ubyte r2L  = $cfe4
+    &ubyte r3L  = $cfe6
+    &ubyte r4L  = $cfe8
+    &ubyte r5L  = $cfea
+    &ubyte r6L  = $cfec
+    &ubyte r7L  = $cfee
+    &ubyte r8L  = $cff0
+    &ubyte r9L  = $cff2
+    &ubyte r10L = $cff4
+    &ubyte r11L = $cff6
+    &ubyte r12L = $cff8
+    &ubyte r13L = $cffa
+    &ubyte r14L = $cffc
+    &ubyte r15L = $cffe
 
-    &ubyte r0H  = $cf01
-    &ubyte r1H  = $cf03
-    &ubyte r2H  = $cf05
-    &ubyte r3H  = $cf07
-    &ubyte r4H  = $cf09
-    &ubyte r5H  = $cf0b
-    &ubyte r6H  = $cf0d
-    &ubyte r7H  = $cf0f
-    &ubyte r8H  = $cf11
-    &ubyte r9H  = $cf13
-    &ubyte r10H = $cf15
-    &ubyte r11H = $cf17
-    &ubyte r12H = $cf19
-    &ubyte r13H = $cf1b
-    &ubyte r14H = $cf1d
-    &ubyte r15H = $cf1f
+    &ubyte r0H  = $cfe1
+    &ubyte r1H  = $cfe3
+    &ubyte r2H  = $cfe5
+    &ubyte r3H  = $cfe7
+    &ubyte r4H  = $cfe9
+    &ubyte r5H  = $cfeb
+    &ubyte r6H  = $cfed
+    &ubyte r7H  = $cfef
+    &ubyte r8H  = $cff1
+    &ubyte r9H  = $cff3
+    &ubyte r10H = $cff5
+    &ubyte r11H = $cff7
+    &ubyte r12H = $cff9
+    &ubyte r13H = $cffb
+    &ubyte r14H = $cffd
+    &ubyte r15H = $cfff
 
-    &byte r0sL  = $cf00
-    &byte r1sL  = $cf02
-    &byte r2sL  = $cf04
-    &byte r3sL  = $cf06
-    &byte r4sL  = $cf08
-    &byte r5sL  = $cf0a
-    &byte r6sL  = $cf0c
-    &byte r7sL  = $cf0e
-    &byte r8sL  = $cf10
-    &byte r9sL  = $cf12
-    &byte r10sL = $cf14
-    &byte r11sL = $cf16
-    &byte r12sL = $cf18
-    &byte r13sL = $cf1a
-    &byte r14sL = $cf1c
-    &byte r15sL = $cf1e
+    &byte r0sL  = $cfe0
+    &byte r1sL  = $cfe2
+    &byte r2sL  = $cfe4
+    &byte r3sL  = $cfe6
+    &byte r4sL  = $cfe8
+    &byte r5sL  = $cfea
+    &byte r6sL  = $cfec
+    &byte r7sL  = $cfee
+    &byte r8sL  = $cff0
+    &byte r9sL  = $cff2
+    &byte r10sL = $cff4
+    &byte r11sL = $cff6
+    &byte r12sL = $cff8
+    &byte r13sL = $cffa
+    &byte r14sL = $cffc
+    &byte r15sL = $cffe
 
-    &byte r0sH  = $cf01
-    &byte r1sH  = $cf03
-    &byte r2sH  = $cf05
-    &byte r3sH  = $cf07
-    &byte r4sH  = $cf09
-    &byte r5sH  = $cf0b
-    &byte r6sH  = $cf0d
-    &byte r7sH  = $cf0f
-    &byte r8sH  = $cf11
-    &byte r9sH  = $cf13
-    &byte r10sH = $cf15
-    &byte r11sH = $cf17
-    &byte r12sH = $cf19
-    &byte r13sH = $cf1b
-    &byte r14sH = $cf1d
-    &byte r15sH = $cf1f
+    &byte r0sH  = $cfe1
+    &byte r1sH  = $cfe3
+    &byte r2sH  = $cfe5
+    &byte r3sH  = $cfe7
+    &byte r4sH  = $cfe9
+    &byte r5sH  = $cfeb
+    &byte r6sH  = $cfed
+    &byte r7sH  = $cfef
+    &byte r8sH  = $cff1
+    &byte r9sH  = $cff3
+    &byte r10sH = $cff5
+    &byte r11sH = $cff7
+    &byte r12sH = $cff9
+    &byte r13sH = $cffb
+    &byte r14sH = $cffd
+    &byte r15sH = $cfff
 
     asmsub save_virtual_registers() clobbers(A,Y) {
         %asm {{

compiler/res/prog8lib/c64/textio.p8

@@ -39,7 +39,7 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
-asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
+asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- fill the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
 
@@ -54,7 +54,7 @@ asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
 
 }
 
-asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
+asmsub  clear_screenchars (ubyte character @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	%asm {{
@@ -96,13 +96,12 @@ sub uppercase() {
     c64.VMCSB &= ~2
 }
 
-asmsub  scroll_left  (bool alsocolors @ Pc) clobbers(A, Y)  {
+asmsub  scroll_left  (bool alsocolors @ Pc) clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -132,17 +131,15 @@ _scroll_screen  ; scroll only the screen memory
 		dey
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_right  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_right  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -168,17 +165,15 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_up  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_up  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -204,17 +199,15 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A,X)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  _scroll_screen
 
 +               ; scroll the screen and the color memory
@@ -240,12 +233,11 @@ _scroll_screen  ; scroll only the screen memory
 		dex
 		bpl  -
 
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
 
 asmsub  print (str text @ AY) clobbers(A,Y)  {
 	; ---- print null terminated string from A/Y
@@ -265,10 +257,9 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -276,16 +267,13 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		pla
 		jsr  cbm.CHROUT
 		txa
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -301,16 +289,13 @@ _print_byte_digits
         beq  _ones
         jsr  cbm.CHROUT
 _ones   txa
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		pha
 		cmp  #0
 		bpl  +
@@ -322,10 +307,9 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -334,16 +318,13 @@ asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  conv.ubyte2hex
 		jsr  cbm.CHROUT
 		tya
-		jsr  cbm.CHROUT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -356,12 +337,11 @@ asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  cbm.CHROUT
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -373,7 +353,7 @@ asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -386,10 +366,9 @@ asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -397,17 +376,14 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  cbm.CHROUT
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG
-		rts
++		rts
 	}}
 }
 
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -428,7 +404,7 @@ _allzero
 	}}
 }
 
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -489,7 +465,7 @@ asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)
 _mod		sta  $ffff		; modified
 		rts
 
-_screenrows	.word  $0400 + range(0, 1000, 40)
+_screenrows	.word  cbm.Screen + range(0, 1000, 40)
 	}}
 }
 
@@ -556,7 +532,7 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor)  {
 	; ---- set char+color at the given position on the screen
 	%asm {{
 		lda  row
@@ -568,13 +544,13 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
 		sta  _colormod+2
 		lda  setchr._screenrows,y
 		clc
-		adc  column
+		adc  col
 		sta  _charmod+1
 		sta  _colormod+1
 		bcc  +
 		inc  _charmod+2
 		inc  _colormod+2
-+		lda  char
++		lda  character
 _charmod	sta  $ffff		; modified
 		lda  charcolor
 _colormod	sta  $ffff		; modified
@@ -582,15 +558,10 @@ _colormod	sta  $ffff		; modified
 	}}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
-	; ---- safe wrapper around PLOT kernal routine, to save the X register.
+asmsub  plot  (ubyte col @ Y, ubyte row @ X) {
 	%asm  {{
-		stx  P8ZP_SCRATCH_REG
-		tax
 		clc
-		jsr  cbm.PLOT
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  cbm.PLOT
 	}}
 }
 

compiler/res/prog8lib/conv.p8

@@ -8,25 +8,22 @@ conv {
 
     str  @shared string_out = "????????????????"       ; result buffer for the string conversion routines
 
-asmsub  str_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  str_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- convert the ubyte in A in decimal string form, with left padding 0s (3 positions total)
 	%asm {{
-            stx  P8ZP_SCRATCH_REG
             jsr  conv.ubyte2decimal
             sty  string_out
             sta  string_out+1
             stx  string_out+2
             lda  #0
             sta  string_out+3
-            ldx  P8ZP_SCRATCH_REG
             rts
 	}}
 }
 
-asmsub  str_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  str_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- convert the ubyte in A in decimal string form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		ldy  #0
 		sty  P8ZP_SCRATCH_B1
 		jsr  conv.ubyte2decimal
@@ -52,15 +49,13 @@ _output_byte_digits
                 iny
                 lda  #0
                 sta  string_out,y
-                ldx  P8ZP_SCRATCH_REG
                 rts
 	}}
 }
 
-asmsub  str_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  str_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- convert the byte in A in decimal string form, without left padding 0s
 	%asm {{
-            stx  P8ZP_SCRATCH_REG
             ldy  #0
             sty  P8ZP_SCRATCH_B1
             cmp  #0
@@ -75,7 +70,7 @@ asmsub  str_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  str_ubhex  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  str_ubhex  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- convert the ubyte in A in hex string form
 	%asm {{
             jsr  conv.ubyte2hex
@@ -87,7 +82,7 @@ asmsub  str_ubhex  (ubyte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  str_ubbin  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  str_ubbin  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- convert the ubyte in A in binary string form
 	%asm {{
 	    sta  P8ZP_SCRATCH_B1
@@ -106,7 +101,7 @@ _digit      sta  string_out,y
 	}}
 }
 
-asmsub  str_uwbin  (uword value @ AY) clobbers(A,Y)  {
+asmsub  str_uwbin  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- convert the uword in A/Y in binary string form
 	%asm {{
 	    sta  P8ZP_SCRATCH_REG
@@ -145,10 +140,9 @@ asmsub  str_uwhex  (uword value @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  str_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  str_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- convert the uword in A/Y in decimal string form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 	    jsr  conv.uword2decimal
 	    ldy  #0
 -           lda  conv.uword2decimal.decTenThousands,y
@@ -156,15 +150,13 @@ asmsub  str_uw0  (uword value @ AY) clobbers(A,Y)  {
             beq  +
             iny
             bne  -
-+           ldx  P8ZP_SCRATCH_REG
-	    rts
++	    rts
 	}}
 }
 
-asmsub  str_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  str_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- convert the uword in A/Y in decimal string form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 	    jsr  conv.uword2decimal
 	    ldx  #0
 _output_digits
@@ -182,7 +174,6 @@ _gotdigit   sta  string_out,x
             bne  _gotdigit
 _end        lda  #0
             sta  string_out,x
-            ldx  P8ZP_SCRATCH_REG
             rts
 
 _allzero    lda  #'0'
@@ -192,12 +183,11 @@ _allzero    lda  #'0'
 	}}
 }
 
-asmsub  str_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  str_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- convert the (signed) word in A/Y in decimal string form, without left padding 0's
 	%asm {{
 	    cpy  #0
 	    bpl  str_uw
-	    stx  P8ZP_SCRATCH_REG
 	    pha
 	    lda  #'-'
 	    sta  string_out
@@ -700,10 +690,9 @@ asmsub  byte2decimal  (byte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
 	}}
 }
 
-asmsub  ubyte2hex  (ubyte value @A) -> ubyte @A, ubyte @Y  {
+asmsub  ubyte2hex  (ubyte value @A) clobbers(X) -> ubyte @A, ubyte @Y  {
 	; ---- A to hex petscii string in AY (first hex char in A, second hex char in Y)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		pha
 		and  #$0f
 		tax
@@ -715,7 +704,6 @@ asmsub  ubyte2hex  (ubyte value @A) -> ubyte @A, ubyte @Y  {
 		lsr  a
 		tax
 		lda  _hex_digits,x
-		ldx  P8ZP_SCRATCH_REG
 		rts
 
 _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as well

compiler/res/prog8lib/cx16/diskio.p8

@@ -43,12 +43,12 @@ diskio {
             ubyte high = cbm.CHRIN()
             txt.print_uw(mkword(high, low))
             txt.spc()
-            ubyte @zp char
+            ubyte @zp character
             repeat {
-                char = cbm.CHRIN()
-                if char==0
+                character = cbm.CHRIN()
+                if character==0
                     break
-                txt.chrout(char)
+                txt.chrout(character)
             }
             txt.nl()
             void cbm.CHRIN()     ; skip 2 bytes
@@ -209,12 +209,12 @@ io_error:
 
             ; read the filename
             repeat {
-                ubyte char = cbm.CHRIN()
-                if char==0
+                ubyte character = cbm.CHRIN()
+                if character==0
                     break
-                if char=='\"'
+                if character=='\"'
                     break
-                @(nameptr) = char
+                @(nameptr) = character
                 nameptr++
             }
 
@@ -290,25 +290,26 @@ close_end:
     sub f_read(uword bufferpointer, uword num_bytes) -> uword {
         ; -- read from the currently open file, up to the given number of bytes.
         ;    returns the actual number of bytes read.  (checks for End-of-file and error conditions)
+        ;    NOTE: cannot be used to load into VRAM.  Use vload() or call cx16.macptr() yourself with the vera data register as address.
         if not iteration_in_progress or not num_bytes
             return 0
 
         list_blocks = 0     ; we reuse this variable for the total number of bytes read
 
         ; commander X16 supports fast block-read via macptr() kernal call
-        uword size
+        uword readsize
         while num_bytes {
-            size = 255
-            if num_bytes<size
-                size = num_bytes
-            size = cx16.macptr(lsb(size), bufferpointer, false)
+            readsize = 255
+            if num_bytes<readsize
+                readsize = num_bytes
+            readsize = cx16.macptr(lsb(readsize), bufferpointer, false)
             if_cs
                 goto byte_read_loop     ; macptr block read not supported, do fallback loop
-            list_blocks += size
-            bufferpointer += size
+            list_blocks += readsize
+            bufferpointer += readsize
             if msb(bufferpointer) == $c0
                 bufferpointer = mkword($a0, lsb(bufferpointer))  ; wrap over bank boundary
-            num_bytes -= size
+            num_bytes -= readsize
             if cbm.READST() & $40 {
                 f_close()       ; end of file, close it
                 break
@@ -347,6 +348,7 @@ m_in_buffer     sta  $ffff
     ; optimized for Commander X16 to use MACPTR block read kernal call
     sub f_read_all(uword bufferpointer) -> uword {
         ; -- read the full contents of the file, returns number of bytes read.
+        ;    NOTE: cannot be used to load into VRAM.  Use vload() or call cx16.macptr() yourself with the vera data register as address.
         if not iteration_in_progress
             return 0
 
@@ -468,27 +470,26 @@ io_error:
 
 
     ; saves a block of memory to disk, including the default 2 byte prg header.
-    sub save(uword filenameptr, uword address, uword size) -> bool {
-        return internal_save_routine(filenameptr, address, size, false)
+    sub save(uword filenameptr, uword startaddress, uword savesize) -> bool {
+        return internal_save_routine(filenameptr, startaddress, savesize, false)
     }
 
     ; like save() but omits the 2 byte prg header.
-    sub save_raw(uword filenameptr, uword address, uword size) -> bool {
-        return internal_save_routine(filenameptr, address, size, true)
+    sub save_raw(uword filenameptr, uword startaddress, uword savesize) -> bool {
+        return internal_save_routine(filenameptr, startaddress, savesize, true)
     }
 
-    sub internal_save_routine(uword filenameptr, uword address, uword size, bool headerless) -> bool {
+    sub internal_save_routine(uword filenameptr, uword startaddress, uword savesize, bool headerless) -> bool {
         cbm.SETNAM(string.length(filenameptr), filenameptr)
         cbm.SETLFS(1, drivenumber, 0)
-        uword @shared end_address = address + size
+        uword @shared end_address = startaddress + savesize
         cx16.r0L = 0
 
         %asm {{
-            lda  address
+            lda  startaddress
             sta  P8ZP_SCRATCH_W1
-            lda  address+1
+            lda  startaddress+1
             sta  P8ZP_SCRATCH_W1+1
-            stx  P8ZP_SCRATCH_REG
             ldx  end_address
             ldy  end_address+1
             lda  headerless
@@ -499,7 +500,6 @@ io_error:
 +           lda  #<P8ZP_SCRATCH_W1
             jsr  cbm.SAVE
 +           php
-            ldx  P8ZP_SCRATCH_REG
             plp
         }}
 
@@ -532,8 +532,8 @@ io_error:
     ; Identical to load(), but DOES INCLUDE the first 2 bytes in the file.
     ; No program header is assumed in the file. Everything is loaded.
     ; See comments on load() for more details.
-    sub load_raw(uword filenameptr, uword address) -> uword {
-        return internal_load_routine(filenameptr, address, true)
+    sub load_raw(uword filenameptr, uword startaddress) -> uword {
+        return internal_load_routine(filenameptr, startaddress, true)
     }
 
 
@@ -547,7 +547,6 @@ io_error:
             secondary |= %00000010  ; activate cx16 kernal headerless load support
         cbm.SETLFS(1, drivenumber, secondary)
         %asm {{
-            stx  P8ZP_SCRATCH_REG
             lda  #0
             ldx  address_override
             ldy  address_override+1
@@ -555,7 +554,7 @@ io_error:
             bcs  +
             stx  cx16.r1
             sty  cx16.r1+1
-+           ldx  P8ZP_SCRATCH_REG
++
         }}
 
         cbm.CLRCHN()
@@ -607,14 +606,13 @@ io_error:
         return $2000 * (cx16.getrambank() - startbank) + endaddress - startaddress
     }
 
-    asmsub vload(str name @R0, ubyte bank @A, uword address @R1) -> ubyte @A {
+    asmsub vload(str name @R0, ubyte bank @A, uword startaddress @R1) clobbers(X, Y) -> ubyte @A {
         ; -- like the basic command VLOAD "filename",drivenumber,bank,address
         ;    loads a file into Vera's video memory in the given bank:address, returns success in A
         ;    the file has to have the usual 2 byte header (which will be skipped)
         %asm {{
             clc
 internal_vload:
-            phx
             pha
             ldx  drivenumber
             bcc +
@@ -642,13 +640,12 @@ internal_vload:
     +       jsr  cbm.CLRCHN
             lda  #1
             jsr  cbm.CLOSE
-            plx
             lda  P8ZP_SCRATCH_B1
             rts
         }}
     }
 
-    asmsub vload_raw(str name @R0, ubyte bank @A, uword address @R1) -> ubyte @A {
+    asmsub vload_raw(str name @R0, ubyte bank @A, uword startaddress @R1) clobbers(X, Y) -> ubyte @A {
         ; -- like the basic command BVLOAD "filename",drivenumber,bank,address
         ;    loads a file into Vera's video memory in the given bank:address, returns success in A
         ;    the file is read fully including the first two bytes.

compiler/res/prog8lib/cx16/floats.p8

@@ -28,7 +28,7 @@ romsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101
 romsub $fe03 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
 romsub $fe06 = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY
-; romsub $fe09 = VAL_1() clobbers(A,X,Y)                      ; convert ASCII string to floating point [not yet implemented!!!]
+; romsub $fe09 = VAL_1() clobbers(A,X,Y)                      ; convert ASCII string to floating point [not yet implemented!!!] see parse_f() instead
 
 ; GETADR: fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
 ; (tip: use GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
@@ -44,7 +44,7 @@ romsub $fe21 = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
 romsub $fe24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1
 romsub $fe27 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  mind the order of the operands
 romsub $fe2a = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
-romsub $fe2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
+romsub $fe2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use ROUND or FADDH first to round instead of trunc
 romsub $fe30 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
 romsub $fe33 = NEGOP() clobbers(A)                          ; switch the sign of fac1 (fac1 = -fac1)
 romsub $fe36 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** float in A/Y
@@ -99,14 +99,11 @@ asmsub  FREADSA  (byte value @A) clobbers(A,X,Y) {
 asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
 	%asm {{
-	phx
 	sty  $c4        ; facmo     ($64 on c128)
 	sta  $c5        ; facmo+1   ($65 on c128)
 	ldx  #$90
 	sec
-	jsr  FLOATC
-	plx
-	rts
+	jmp  FLOATC
 	}}
 }
 
@@ -139,16 +136,26 @@ asmsub  FREADUY (ubyte value @Y) {
     }}
 }
 
+asmsub parse_f(str value @AY) -> float @FAC1 {
+    ; -- parse a string value of a number to float in FAC1
+    ;    warning: uses an internal BASIC routine that may be rom version dependent
+    ;    ($ddf2 is inside the routine for VAL at $ddef)
+    %asm {{
+        sta  $a9
+        sty  $aa
+        jsr  prog8_lib.strlen
+        tya
+        jmp  $ddf2
+    }}
+}
+
 
 &uword AYINT_facmo = $c6      ; $c6/$c7 contain result of AYINT
 
 sub rndf() -> float {
     %asm {{
-        phx
         lda  #1
-        jsr  RND_0
-        plx
-        rts
+        jmp  RND_0
     }}
 }
 

compiler/res/prog8lib/cx16/gfx2.p8

@@ -20,8 +20,6 @@
 ;   mode 6 = bitmap 640 x 480 x 4c
 ;   higher color dephts in highres are not supported due to lack of VRAM
 
-; TODO remove the phx/plx pairs in non-stack compiler version
-
 gfx2 {
 
     %option no_symbol_prefixing
@@ -135,51 +133,61 @@ gfx2 {
         monochrome_dont_stipple_flag = not enable
     }
 
-    sub rect(uword x, uword y, uword rwidth, uword rheight, ubyte color) {
+    sub rect(uword xx, uword yy, uword rwidth, uword rheight, ubyte color) {
         if rwidth==0 or rheight==0
             return
-        horizontal_line(x, y, rwidth, color)
+        horizontal_line(xx, yy, rwidth, color)
         if rheight==1
             return
-        horizontal_line(x, y+rheight-1, rwidth, color)
-        vertical_line(x, y+1, rheight-2, color)
+        horizontal_line(xx, yy+rheight-1, rwidth, color)
+        vertical_line(xx, yy+1, rheight-2, color)
         if rwidth==1
             return
-        vertical_line(x+rwidth-1, y+1, rheight-2, color)
+        vertical_line(xx+rwidth-1, yy+1, rheight-2, color)
     }
 
-    sub fillrect(uword x, uword y, uword rwidth, uword rheight, ubyte color) {
+    sub fillrect(uword xx, uword yy, uword rwidth, uword rheight, ubyte color) {
         if rwidth==0
             return
         repeat rheight {
-            horizontal_line(x, y, rwidth, color)
-            y++
+            horizontal_line(xx, yy, rwidth, color)
+            yy++
         }
     }
 
-    sub horizontal_line(uword x, uword y, uword length, ubyte color) {
-        ubyte[9] masked_ends   = [ 0, %10000000, %11000000, %11100000, %11110000, %11111000, %11111100, %11111110, %11111111]
+    sub horizontal_line(uword xx, uword yy, uword length, ubyte color) {
         ubyte[9] masked_starts = [ 0, %00000001, %00000011, %00000111, %00001111, %00011111, %00111111, %01111111, %11111111]
+        ubyte[9] masked_ends   = [ 0, %10000000, %11000000, %11100000, %11110000, %11111000, %11111100, %11111110, %11111111]
 
         if length==0
             return
         when active_mode {
             1, 5 -> {
                 ; monochrome modes, either resolution
-                ubyte separate_pixels = (8-lsb(x)) & 7
+                ubyte separate_pixels = (8-lsb(xx)) & 7
                 if separate_pixels as uword > length
                     separate_pixels = lsb(length)
                 if separate_pixels {
-                    position(x,y)
-                    cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
-                    cx16.VERA_DATA0 = cx16.VERA_DATA0 | masked_starts[separate_pixels]
+                    if monochrome_dont_stipple_flag {
+                        position(xx,yy)
+                        cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
+                        if color
+                            cx16.VERA_DATA0 |= masked_starts[separate_pixels]
+                        else
+                            cx16.VERA_DATA0 &= ~masked_starts[separate_pixels]
+                        xx += separate_pixels
+                    } else {
+                        repeat separate_pixels {
+                            plot(xx, yy, color)
+                            xx++
+                        }
+                    }
                     length -= separate_pixels
-                    x += separate_pixels
                 }
                 if length {
-                    position(x, y)
+                    position(xx, yy)
                     separate_pixels = lsb(length) & 7
-                    x += length & $fff8
+                    xx += length & $fff8
                     %asm {{
                         lsr  length+1
                         ror  length
@@ -195,7 +203,7 @@ gfx2 {
                         beq  _stipple
                         ldy  #255       ; don't stipple
                         bra  _loop
-_stipple                lda  y
+_stipple                lda  yy
                         and  #1         ; determine stipple pattern to use
                         bne  +
                         ldy  #%01010101
@@ -213,17 +221,26 @@ _loop                   lda  length
 _done
                     }}
 
-                    cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
-                    cx16.VERA_DATA0 = cx16.VERA_DATA0 | masked_ends[separate_pixels]
+                    if monochrome_dont_stipple_flag {
+                        cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
+                        if color
+                            cx16.VERA_DATA0 |= masked_ends[separate_pixels]
+                        else
+                            cx16.VERA_DATA0 &= ~masked_ends[separate_pixels]
+                    } else {
+                        repeat separate_pixels {
+                            plot(xx, yy, color)
+                            xx++
+                        }
+                    }
                 }
                 cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off again
             }
             4 -> {
                 ; lores 256c
-                position(x, y)
+                position(xx, yy)
                 %asm {{
                     lda  color
-                    phx
                     ldx  length+1
                     beq  +
                     ldy  #0
@@ -237,7 +254,7 @@ _done
 -                   sta  cx16.VERA_DATA0
                     dey
                     bne  -
-+                   plx
++
                 }}
             }
             6 -> {
@@ -249,7 +266,7 @@ _done
                     colorbits[ii] = color
                     color <<= 2
                 }
-                void addr_mul_24_for_highres_4c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
                     lda  cx16.VERA_ADDR_H
                     and  #%00000111         ; no auto advance
@@ -262,8 +279,7 @@ _done
                     sta  cx16.VERA_ADDR_L
                     lda  cx16.r0+1
                     sta  cx16.VERA_ADDR_M
-                    phx
-                    ldx  x
+                    ldx  xx
                 }}
 
                 repeat length {
@@ -285,23 +301,19 @@ _done
 +                       inx                     ; next pixel
                     }}
                 }
-
-                %asm {{
-                    plx
-                }}
             }
         }
     }
 
-    sub vertical_line(uword x, uword y, uword lheight, ubyte color) {
+    sub vertical_line(uword xx, uword yy, uword lheight, ubyte color) {
         when active_mode {
             1, 5 -> {
                 ; monochrome, lo-res
-                cx16.r15L = gfx2.plot.bits[x as ubyte & 7]           ; bitmask
+                cx16.r15L = gfx2.plot.maskbits[xx as ubyte & 7]           ; bitmask
                 if color {
                     if monochrome_dont_stipple_flag {
                         ; draw continuous line.
-                        position2(x,y,true)
+                        position2(xx,yy,true)
                         if active_mode==1
                             set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
                         else
@@ -315,11 +327,11 @@ _done
                         }
                     } else {
                         ; draw stippled line.
-                        if x&1 {
-                            y++
+                        if xx&1 {
+                            yy++
                             lheight--
                         }
-                        position2(x,y,true)
+                        position2(xx,yy,true)
                         if active_mode==1
                             set_both_strides(12)    ; 80 increment = 2 line in 320 px monochrome
                         else
@@ -333,7 +345,7 @@ _done
                         }
                     }
                 } else {
-                    position2(x,y,true)
+                    position2(xx,yy,true)
                     cx16.r15 = ~cx16.r15    ; erase pixels
                     if active_mode==1
                         set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
@@ -351,7 +363,7 @@ _done
             4 -> {
                 ; lores 256c
                 ; set vera auto-increment to 320 pixel increment (=next line)
-                position(x,y)
+                position(xx,yy)
                 cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | (14<<4)
                 %asm {{
                     ldy  lheight
@@ -368,17 +380,17 @@ _done
                 ; use TWO vera adress pointers simultaneously one for reading, one for writing, so auto-increment is possible
                 if lheight==0
                     return
-                position2(x,y,true)
+                position2(xx,yy,true)
                 set_both_strides(13)    ; 160 increment = 1 line in 640 px 4c mode
                 ;; color &= 3
-                ;; color <<= gfx2.plot.shift4c[lsb(x) & 3]
-                cx16.r2L = lsb(x) & 3
+                ;; color <<= gfx2.plot.shift4c[lsb(xx) & 3]
+                cx16.r2L = lsb(xx) & 3
                 when color & 3 {
                     1 -> color = gfx2.plot.shiftedleft_4c_1[cx16.r2L]
                     2 -> color = gfx2.plot.shiftedleft_4c_2[cx16.r2L]
                     3 -> color = gfx2.plot.shiftedleft_4c_3[cx16.r2L]
                 }
-                ubyte @shared mask = gfx2.plot.mask4c[lsb(x) & 3]
+                ubyte @shared mask = gfx2.plot.mask4c[lsb(xx) & 3]
                 repeat lheight {
                     %asm {{
                         lda  cx16.VERA_DATA0
@@ -427,17 +439,17 @@ _done
         }
 
         word @zp d = 0
-        cx16.r13 = true      ; 'positive_ix'
+        cx16.r1L = true      ; 'positive_ix'
         if dx < 0 {
             dx = -dx
-            cx16.r13 = false
+            cx16.r1L = false
         }
         word @zp dx2 = dx*2
         word @zp dy2 = dy*2
         cx16.r14 = x1       ; internal plot X
 
         if dx >= dy {
-            if cx16.r13 {
+            if cx16.r1L {
                 repeat {
                     plot(cx16.r14, y1, color)
                     if cx16.r14==x2
@@ -464,7 +476,7 @@ _done
             }
         }
         else {
-            if cx16.r13 {
+            if cx16.r1L {
                 repeat {
                     plot(cx16.r14, y1, color)
                     if y1 == y2
@@ -557,8 +569,8 @@ _done
         }
     }
 
-    sub plot(uword @zp x, uword @zp y, ubyte @zp color) {
-        ubyte[8] @shared bits = [128, 64, 32, 16, 8, 4, 2, 1]
+    sub plot(uword @zp xx, uword @zp yy, ubyte @zp color) {
+        ubyte[8] @shared maskbits = [128, 64, 32, 16, 8, 4, 2, 1]
         ubyte[4] @shared mask4c = [%00111111, %11001111, %11110011, %11111100]
         ubyte[4] @shared shift4c = [6,4,2,0]
         ubyte[4] shiftedleft_4c_1 = [1<<6, 1<<4, 1<<2, 1<<0]
@@ -568,42 +580,32 @@ _done
         when active_mode {
             1 -> {
                 ; lores monochrome
-                %asm {{
-                    lda  x
-                    eor  y
-                    ora  monochrome_dont_stipple_flag
-                    and  #1
-                }}
-                if_nz {
+                if color {
+                    ; solid color or perhaps stipple
                     %asm {{
-                        lda  x
-                        and  #7
-                        pha     ; xbits
+                        lda  xx
+                        eor  yy
+                        ora  monochrome_dont_stipple_flag
+                        and  #1
                     }}
-                    x /= 8
-                    x += y*(320/8)
+                    if_nz {
+                        mode_1_prepare()
+                        %asm {{
+                            tsb  cx16.VERA_DATA0
+                        }}
+                    }
+                } else {
+                    ; only erase
+                    mode_1_prepare()
                     %asm {{
-                        stz  cx16.VERA_CTRL
-                        stz  cx16.VERA_ADDR_H
-                        lda  x+1
-                        sta  cx16.VERA_ADDR_M
-                        lda  x
-                        sta  cx16.VERA_ADDR_L
-                        ply         ; xbits
-                        lda  bits,y
-                        ldy  color
-                        beq  +
-                        tsb  cx16.VERA_DATA0
-                        bra  ++
-+                       trb  cx16.VERA_DATA0
-+
+                        trb  cx16.VERA_DATA0
                     }}
                 }
             }
             ; TODO modes 2, 3
             4 -> {
                 ; lores 256c
-                void addr_mul_24_for_lores_256c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
                     stz  cx16.VERA_CTRL
                     lda  cx16.r1
@@ -619,42 +621,32 @@ _done
             }
             5 -> {
                 ; highres monochrome
-                %asm {{
-                    lda  x
-                    eor  y
-                    ora  monochrome_dont_stipple_flag
-                    and  #1
-                }}
-                if_nz {
+                if color {
+                    ; solid color or perhaps stipple
                     %asm {{
-                        lda  x
-                        and  #7
-                        pha     ; xbits
+                        lda  xx
+                        eor  yy
+                        ora  monochrome_dont_stipple_flag
+                        and  #1
                     }}
-                    x /= 8
-                    x += y*(640/8)
+                    if_nz {
+                        mode_5_prepare()
+                        %asm {{
+                            tsb  cx16.VERA_DATA0
+                        }}
+                    }
+                } else {
+                    ; only erase
+                    mode_5_prepare()
                     %asm {{
-                        stz  cx16.VERA_CTRL
-                        stz  cx16.VERA_ADDR_H
-                        lda  x+1
-                        sta  cx16.VERA_ADDR_M
-                        lda  x
-                        sta  cx16.VERA_ADDR_L
-                        ply     ; xbits
-                        lda  bits,y
-                        ldy  color
-                        beq  +
-                        tsb  cx16.VERA_DATA0
-                        bra  ++
-+                       trb  cx16.VERA_DATA0
-+
+                        trb  cx16.VERA_DATA0
                     }}
                 }
             }
             6 -> {
                 ; highres 4c   ....also mostly usable for mode 2, lores 4c?
-                void addr_mul_24_for_highres_4c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
-                cx16.r2L = lsb(x) & 3       ; xbits
+                void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
+                cx16.r2L = lsb(xx) & 3       ; xbits
                 ; color &= 3
                 ; color <<= shift4c[cx16.r2L]
                 when color & 3 {
@@ -678,28 +670,68 @@ _done
                 }}
             }
         }
+
+        sub mode_1_prepare() {
+            %asm {{
+                lda  xx
+                and  #7
+                pha     ; xbits
+            }}
+            xx /= 8
+            xx += yy*(320/8)
+            %asm {{
+                stz  cx16.VERA_CTRL
+                stz  cx16.VERA_ADDR_H
+                lda  xx+1
+                sta  cx16.VERA_ADDR_M
+                lda  xx
+                sta  cx16.VERA_ADDR_L
+                ply     ; xbits
+                lda  maskbits,y
+            }}
+        }
+
+        sub mode_5_prepare() {
+            %asm {{
+                lda  xx
+                and  #7
+                pha     ; xbits
+            }}
+            xx /= 8
+            xx += yy*(640/8)
+            %asm {{
+                stz  cx16.VERA_CTRL
+                stz  cx16.VERA_ADDR_H
+                lda  xx+1
+                sta  cx16.VERA_ADDR_M
+                lda  xx
+                sta  cx16.VERA_ADDR_L
+                ply     ; xbits
+                lda  maskbits,y
+            }}
+        }
     }
 
-    sub pget(uword @zp x, uword y) -> ubyte {
+    sub pget(uword @zp xx, uword yy) -> ubyte {
         when active_mode {
             1 -> {
                 ; lores monochrome
                 %asm {{
-                    lda  x
+                    lda  xx
                     and  #7
                     pha     ; xbits
                 }}
-                x /= 8
-                x += y*(320/8)
+                xx /= 8
+                xx += yy*(320/8)
                 %asm {{
                     stz  cx16.VERA_CTRL
                     stz  cx16.VERA_ADDR_H
-                    lda  x+1
+                    lda  xx+1
                     sta  cx16.VERA_ADDR_M
-                    lda  x
+                    lda  xx
                     sta  cx16.VERA_ADDR_L
                     ply         ; xbits
-                    lda  plot.bits,y
+                    lda  plot.maskbits,y
                     and  cx16.VERA_DATA0
                     beq  +
                     lda  #1
@@ -709,7 +741,7 @@ _done
             ; TODO modes 2, 3
             4 -> {
                 ; lores 256c
-                void addr_mul_24_for_lores_256c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
                     stz  cx16.VERA_CTRL
                     lda  cx16.r1
@@ -724,21 +756,21 @@ _done
             5 -> {
                 ; hires monochrome
                 %asm {{
-                    lda  x
+                    lda  xx
                     and  #7
                     pha     ; xbits
                 }}
-                x /= 8
-                x += y*(640/8)
+                xx /= 8
+                xx += yy*(640/8)
                 %asm {{
                     stz  cx16.VERA_CTRL
                     stz  cx16.VERA_ADDR_H
-                    lda  x+1
+                    lda  xx+1
                     sta  cx16.VERA_ADDR_M
-                    lda  x
+                    lda  xx
                     sta  cx16.VERA_ADDR_L
                     ply     ; xbits
-                    lda  plot.bits,y
+                    lda  plot.maskbits,y
                     and  cx16.VERA_DATA0
                     beq  +
                     lda  #1
@@ -747,7 +779,7 @@ _done
             }
             6 -> {
                 ; hires 4c
-                void addr_mul_24_for_highres_4c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
                     stz  cx16.VERA_CTRL
                     lda  cx16.r1L
@@ -759,7 +791,7 @@ _done
                     lda  cx16.VERA_DATA0
                     sta  cx16.r0L
                 }}
-                cx16.r1L = lsb(x) & 3
+                cx16.r1L = lsb(xx) & 3
                 cx16.r0L >>= gfx2.plot.shift4c[cx16.r1L]
                 return cx16.r0L & 3
             }
@@ -767,7 +799,7 @@ _done
         }
     }
 
-    sub fill(word @zp x, word @zp y, ubyte new_color) {
+    sub fill(word @zp xx, word @zp yy, ubyte new_color) {
         ; Non-recursive scanline flood fill.
         ; based loosely on code found here https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
         ; with the fixes applied to the seedfill_4 routine as mentioned in the comments.
@@ -830,85 +862,85 @@ _done
                 lda  stack_xr_msb,y
                 sta  x2+1
                 lda  stack_y_lsb,y
-                sta  y
+                sta  yy
                 lda  stack_y_msb,y
-                sta  y+1
+                sta  yy+1
                 ldy  cx16.r12L
                 lda  stack_dy,y
                 sta  dy
             }}
-            y+=dy
+            yy+=dy
         }
-        cx16.r11L = pget(x as uword, y as uword)        ; old_color
+        cx16.r11L = pget(xx as uword, yy as uword)        ; old_color
         if cx16.r11L == cx16.r10L
             return
-        if x<0 or x > width-1 or y<0 or y > height-1
+        if xx<0 or xx>width-1 or yy<0 or yy>height-1
             return
-        push_stack(x, x, y, 1)
-        push_stack(x, x, y + 1, -1)
+        push_stack(xx, xx, yy, 1)
+        push_stack(xx, xx, yy + 1, -1)
         word left = 0
         while cx16.r12L {
             pop_stack()
-            x = x1
-            while x >= 0 and pget(x as uword, y as uword) == cx16.r11L {
-                plot(x as uword, y as uword, cx16.r10L)
-                x--
+            xx = x1
+            while xx >= 0 and pget(xx as uword, yy as uword) == cx16.r11L {
+                plot(xx as uword, yy as uword, cx16.r10L)
+                xx--
             }
-            if x>= x1
+            if xx >= x1
                 goto skip
 
-            left = x + 1
+            left = xx + 1
             if left < x1
-                push_stack(left, x1 - 1, y, -dy)
-            x = x1 + 1
+                push_stack(left, x1 - 1, yy, -dy)
+            xx = x1 + 1
 
             do {
-                while x <= width-1 and pget(x as uword, y as uword) == cx16.r11L {
-                    plot(x as uword, y as uword, cx16.r10L)
-                    x++
+                while xx <= width-1 and pget(xx as uword, yy as uword) == cx16.r11L {
+                    plot(xx as uword, yy as uword, cx16.r10L)
+                    xx++
                 }
-                push_stack(left, x - 1, y, dy)
-                if x > x2 + 1
-                    push_stack(x2 + 1, x - 1, y, -dy)
+                push_stack(left, xx - 1, yy, dy)
+                if xx > x2 + 1
+                    push_stack(x2 + 1, xx - 1, yy, -dy)
 skip:
-                x++
-                while x <= x2 and pget(x as uword, y as uword) != cx16.r11L
-                    x++
-                left = x
-            } until x>x2
+                xx++
+                while xx <= x2 and pget(xx as uword, yy as uword) != cx16.r11L
+                    xx++
+                left = xx
+            } until xx>x2
         }
     }
 
-    sub position(uword @zp x, uword y) {
+    sub position(uword @zp xx, uword yy) {
         when active_mode {
             1 -> {
                 ; lores monochrome
-                cx16.r0 = y*(320/8) + x/8
+                cx16.r0 = yy*(320/8) + xx/8
                 cx16.vaddr(0, cx16.r0, 0, 1)
             }
             ; TODO modes 2, 3
             4 -> {
                 ; lores 256c
-                void addr_mul_24_for_lores_256c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 cx16.r2L = cx16.r1L
                 cx16.vaddr(cx16.r2L, cx16.r0, 0, 1)
             }
             5 -> {
                 ; highres monochrome
-                cx16.r0 = y*(640/8) + x/8
+                cx16.r0 = yy*(640/8) + xx/8
                 cx16.vaddr(0, cx16.r0, 0, 1)
             }
             6 -> {
                 ; highres 4c
-                void addr_mul_24_for_highres_4c(y, x)      ; 24 bits result is in r0 and r1L (highest byte)
+                void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 cx16.r2L = cx16.r1L
                 cx16.vaddr(cx16.r2L, cx16.r0, 0, 1)
             }
         }
     }
 
-    sub position2(uword @zp x, uword y, bool also_port_1) {
-        position(x, y)
+    sub position2(uword @zp xx, uword yy, bool also_port_1) {
+        position(xx, yy)
         if also_port_1
             cx16.vaddr_clone(0)
     }
@@ -923,13 +955,12 @@ skip:
         }}
     }
 
-    asmsub next_pixels(uword pixels @AY, uword amount @R0) clobbers(A, Y)  {
+    asmsub next_pixels(uword pixels @AY, uword amount @R0) clobbers(A, X, Y)  {
         ; -- sets the next bunch of pixels from a prepared array of bytes.
         ;    for 8 bpp screens this will plot 1 pixel per byte.
         ;    for 1 bpp screens it will plot 8 pixels at once (colors are the bit patterns per byte).
         ;    for 2 bpp screens it will plot 4 pixels at once (colors are the bit patterns per byte).
         %asm {{
-            phx
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
             ldx  cx16.r0+1
@@ -951,14 +982,13 @@ skip:
             iny
             dex
             bne  -
-+           plx
++           rts
         }}
     }
 
-    asmsub set_8_pixels_from_bits(ubyte bits @R0, ubyte oncolor @A, ubyte offcolor @Y) {
+    asmsub set_8_pixels_from_bits(ubyte bits @R0, ubyte oncolor @A, ubyte offcolor @Y) clobbers(X) {
         ; this is only useful in 256 color mode where one pixel equals one byte value.
         %asm {{
-            phx
             ldx  #8
 -           asl  cx16.r0
             bcc  +
@@ -967,7 +997,6 @@ skip:
 +           sty  cx16.VERA_DATA0
 +           dex
             bne  -
-            plx
             rts
         }}
     }
@@ -982,7 +1011,7 @@ skip:
         cx16.screen_set_charset(charset, 0)
     }
 
-    sub text(uword @zp x, uword y, ubyte color, uword sctextptr) {
+    sub text(uword @zp xx, uword yy, ubyte color, uword sctextptr) {
         ; -- Write some text at the given pixel position. The text string must be in screencode encoding (not petscii!).
         ;    You must also have called text_charset() first to select and prepare the character set to use.
         uword chardataptr
@@ -999,8 +1028,7 @@ skip:
                     cx16.vaddr_autoincr(charset_bank, chardataptr, 0, 1)
                     %asm {{
                         ; pre-shift the bits
-                        phx ; TODO remove in non-stack version
-                        lda  text.x
+                        lda  text.xx
                         and  #7
                         sta  P8ZP_SCRATCH_B1
                         ldy  #0
@@ -1019,10 +1047,9 @@ skip:
                         iny
                         cpy  #8
                         bne  --
-                        plx     ; TODO remove in non-stack version
                     }}
                     ; left part of shifted char
-                    position2(x, y, true)
+                    position2(xx, yy, true)
                     set_autoincrs_mode1_or_5()
                     if color {
                         %asm {{
@@ -1047,8 +1074,8 @@ skip:
                         }}
                     }
                     ; right part of shifted char
-                    if lsb(x) & 7 {
-                        position2(x+8, y, true)
+                    if lsb(xx) & 7 {
+                        position2(xx+8, yy, true)
                         set_autoincrs_mode1_or_5()
                         if color {
                             %asm {{
@@ -1074,7 +1101,7 @@ skip:
                         }
                     }
                     cx16.r3++
-                    x += 8
+                    xx += 8
                 }
             }
             4 -> {
@@ -1083,10 +1110,9 @@ skip:
                     chardataptr = charset_addr + (@(sctextptr) as uword)*8
                     cx16.vaddr(charset_bank, chardataptr, 1, 1)
                     repeat 8 {
-                        position(x,y)
-                        y++
+                        position(xx,yy)
+                        yy++
                         %asm {{
-                            phx ; TODO remove in non-stack version
                             ldx  color
                             lda  cx16.VERA_DATA1
                             sta  P8ZP_SCRATCH_B1
@@ -1098,11 +1124,10 @@ skip:
 +                           lda  cx16.VERA_DATA0    ; don't write a pixel, but do advance to the next address
 +                           dey
                             bne  -
-                            plx ; TODO remove in non-stack version
                         }}
                     }
-                    x+=8
-                    y-=8
+                    xx+=8
+                    yy-=8
                     sctextptr++
                 }
             }
@@ -1113,11 +1138,11 @@ skip:
                 while @(sctextptr) {
                     chardataptr = charset_addr + (@(sctextptr) as uword)*8
                     cx16.vaddr(charset_bank, chardataptr, 1, true)  ; for reading the chardata from Vera data channel 1
-                    position(x, y)              ; only calculated once, we update vera address in the loop instead
+                    position(xx, yy)              ; only calculated once, we update vera address in the loop instead
                     cx16.VERA_ADDR_H &= $0f     ; no auto increment
                     repeat 8 {
                         cx16.r10L = cx16.VERA_DATA1  ; get the next 8 horizontal character bits
-                        cx16.r7 = x
+                        cx16.r7 = xx
                         repeat 8 {
                             cx16.r10L <<= 1
                             if_cs {
@@ -1164,7 +1189,7 @@ skip:
                             sta  cx16.VERA_ADDR_H
                         }}
                     }
-                    x+=8
+                    xx+=8
                     sctextptr++
                 }
             }

compiler/res/prog8lib/cx16/graphics.p8

@@ -50,22 +50,22 @@ graphics {
         cx16.GRAPH_draw_line(x1, y1, x2, y2)
     }
 
-    sub fillrect(uword x, uword y, uword width, uword height) {
-        cx16.GRAPH_draw_rect(x, y, width, height, 0, 1)
+    sub fillrect(uword xx, uword yy, uword width, uword height) {
+        cx16.GRAPH_draw_rect(xx, yy, width, height, 0, 1)
     }
 
-    sub rect(uword x, uword y, uword width, uword height) {
-        cx16.GRAPH_draw_rect(x, y, width, height, 0, 0)
+    sub rect(uword xx, uword yy, uword width, uword height) {
+        cx16.GRAPH_draw_rect(xx, yy, width, height, 0, 0)
     }
 
-    sub horizontal_line(uword x, uword y, uword length) {
+    sub horizontal_line(uword xx, uword yy, uword length) {
         if length
-            cx16.GRAPH_draw_line(x, y, x+length-1, y)
+            cx16.GRAPH_draw_line(xx, yy, xx+length-1, yy)
     }
 
-    sub vertical_line(uword x, uword y, uword height) {
+    sub vertical_line(uword xx, uword yy, uword height) {
         if height
-            cx16.GRAPH_draw_line(x, y, x, y+height-1)
+            cx16.GRAPH_draw_line(xx, yy, xx, yy+height-1)
     }
 
     sub circle(uword xcenter, ubyte ycenter, ubyte radius) {

compiler/res/prog8lib/cx16/psg.p8

@@ -16,11 +16,11 @@ psg {
     const ubyte LEFT     = %01000000
     const ubyte RIGHT    = %10000000
 
-    sub voice(ubyte voice_num, ubyte channel, ubyte volume, ubyte waveform, ubyte pulsewidth) {
+    sub voice(ubyte voice_num, ubyte channel, ubyte vol, ubyte waveform, ubyte pulsewidth) {
         ; -- Enables a 'voice' on the PSG.
         ;    voice_num = 0-15, the voice number.
         ;    channel = either LEFT or RIGHT or (LEFT|RIGHT). Specifies the stereo channel(s) to use.
-        ;    volume = 0-63, the starting volume for the voice
+        ;    vol = 0-63, the starting volume for the voice
         ;    waveform = one of PULSE,SAWTOOTH,TRIANGLE,NOISE.
         ;    pulsewidth = 0-63.  Specifies the pulse width for waveform=PULSE.
         envelope_states[voice_num] = 255
@@ -30,11 +30,11 @@ psg {
         cx16.VERA_ADDR_L = lsb(cx16.r0)
         cx16.VERA_ADDR_M = msb(cx16.r0)
         cx16.VERA_ADDR_H = 1
-        cx16.VERA_DATA0 = channel | volume
+        cx16.VERA_DATA0 = channel | vol
         cx16.VERA_ADDR_L++
         cx16.VERA_DATA0 = waveform | pulsewidth
-        envelope_volumes[voice_num] = mkword(volume, 0)
-        envelope_maxvolumes[voice_num] = volume
+        envelope_volumes[voice_num] = mkword(vol, 0)
+        envelope_maxvolumes[voice_num] = vol
         sys.irqsafe_clear_irqd()
     }
 

compiler/res/prog8lib/cx16/syslib.p8

@@ -38,7 +38,7 @@ romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc    ; (via 798
 romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
 romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
 romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
+romsub $FFD2 = CHROUT(ubyte character @ A)                           ; (via 806 ($326)) output a character
 romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A, uword @ XY     ; (via 816 ($330)) load from device
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A       ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
@@ -53,25 +53,21 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 ; ---- utility
 
-asmsub STOP2() -> ubyte @A  {
+asmsub STOP2() clobbers(X) -> ubyte @A  {
     ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
     %asm {{
-        phx
         jsr  cbm.STOP
         beq  +
-        plx
         lda  #0
         rts
-+       plx
-        lda  #1
++       lda  #1
         rts
     }}
 }
 
-asmsub RDTIM16() -> uword @AY {
+asmsub RDTIM16() clobbers(X) -> uword @AY {
     ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience. Also avoids ram bank issue for irqs.
     %asm {{
-        phx
         php
         sei
         jsr  cbm.RDTIM
@@ -81,7 +77,6 @@ asmsub RDTIM16() -> uword @AY {
         txa
         tay
         pla
-        plx
         rts
     }}
 }
@@ -351,8 +346,8 @@ romsub $ff35 = GRAPH_draw_oval(uword x @R0, uword y @R1, uword width @R2, uword
 romsub $ff38 = GRAPH_draw_image(uword x @R0, uword y @R1, uword ptr @R2, uword width @R3, uword height @R4)  clobbers(A,X,Y)
 romsub $ff3b = GRAPH_set_font(uword fontptr @R0)  clobbers(A,X,Y)
 romsub $ff3e = GRAPH_get_char_size(ubyte baseline @A, ubyte width @X, ubyte height_or_style @Y, bool is_control @Pc)  clobbers(A,X,Y)
-romsub $ff41 = GRAPH_put_char(uword x @R0, uword y @R1, ubyte char @A)  clobbers(A,X,Y)
-romsub $ff41 = GRAPH_put_next_char(ubyte char @A)  clobbers(A,X,Y)     ; alias for the routine above that doesn't reset the position of the initial character
+romsub $ff41 = GRAPH_put_char(uword x @R0, uword y @R1, ubyte character @A)  clobbers(A,X,Y)
+romsub $ff41 = GRAPH_put_next_char(ubyte character @A)  clobbers(A,X,Y)     ; alias for the routine above that doesn't reset the position of the initial character
 
 ; framebuffer
 romsub $fef6 = FB_init()  clobbers(A,X,Y)
@@ -382,7 +377,7 @@ romsub $fee7 = memory_copy(uword source @R0, uword target @R1, uword num_bytes @
 romsub $feea = memory_crc(uword address @R0, uword num_bytes @R1)  clobbers(A,X,Y) -> uword @R2
 romsub $feed = memory_decompress(uword input @R0, uword output @R1)  clobbers(A,X,Y) -> uword @R1       ; last address +1 is result in R1
 romsub $fedb = console_init(uword x @R0, uword y @R1, uword width @R2, uword height @R3)  clobbers(A,X,Y)
-romsub $fede = console_put_char(ubyte char @A, bool wrapping @Pc)  clobbers(A,X,Y)
+romsub $fede = console_put_char(ubyte character @A, bool wrapping @Pc)  clobbers(A,X,Y)
 romsub $fee1 = console_get_char()  clobbers(X,Y) -> ubyte @A
 romsub $fed8 = console_put_image(uword pointer @R0, uword width @R1, uword height @R2)  clobbers(A,X,Y)
 romsub $fed5 = console_set_paging_message(uword msgptr @R0)  clobbers(A,X,Y)
@@ -454,15 +449,12 @@ asmsub mouse_config2(ubyte shape @A) clobbers (A, X, Y) {
     }}
 }
 
-asmsub mouse_pos() -> ubyte @A {
+asmsub mouse_pos() clobbers(X) -> ubyte @A {
     ; -- short wrapper around mouse_get() kernal routine:
     ; -- gets the position of the mouse cursor in cx16.r0 and cx16.r1 (x/y coordinate), returns mouse button status.
     %asm {{
-        phx
         ldx  #cx16.r0
-        jsr  cx16.mouse_get
-        plx
-        rts
+        jmp  cx16.mouse_get
     }}
 }
 
@@ -500,7 +492,7 @@ inline asmsub getrambank() -> ubyte @A {
     }}
 }
 
-asmsub numbanks() -> uword @AY {
+asmsub numbanks() clobbers(X) -> uword @AY {
     ; -- Returns the number of available RAM banks according to the kernal (each bank is 8 Kb).
     ;    Note that the number of such banks can be 256 so a word is returned.
     ;    But just looking at the A register (the LSB of the result word) could suffice if you know that A=0 means 256 banks:
@@ -508,15 +500,13 @@ asmsub numbanks() -> uword @AY {
     ;    Kernal's MEMTOP routine reports 0 in this case but that doesn't mean 'zero banks', instead it means 256 banks,
     ;    as there is no X16 without at least 1 page of banked RAM. So this routine returns 256 instead of 0.
     %asm {{
-        phx
         sec
         jsr  cbm.MEMTOP
         ldy  #0
         cmp  #0
         bne  +
         iny
-+       plx
-        rts
++       rts
     }}
 }
 
@@ -956,10 +946,6 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
-		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
-		; We assume IRQ handlers don't contain complex expressions taking up more than that.
-		ldx  #32
 		cld
 		rts
 
@@ -1079,19 +1065,17 @@ asmsub  set_rasterline(uword line @AY) {
         void cx16.i2c_write_byte($42, $05, activity)
     }
 
-    asmsub wait(uword jiffies @AY) {
+    asmsub wait(uword jiffies @AY) clobbers(X) {
         ; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
         ;     note: the system irq handler has to be active for this to work as it depends on the system jiffy clock
         ;     note: this routine cannot be used from inside a irq handler
         %asm {{
-            phx
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
 
 _loop       lda  P8ZP_SCRATCH_W1
             ora  P8ZP_SCRATCH_W1+1
             bne  +
-            plx
             rts
 
 +           sei

compiler/res/prog8lib/cx16/textio.p8

@@ -42,11 +42,10 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
-asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
+asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A, X)  {
 	; ---- fill the character screen with the given fill character and character color.
 	%asm {{
         sty  _ly+1
-        phx
         pha
         jsr  cbm.SCREEN             ; get dimensions in X/Y
         txa
@@ -75,8 +74,7 @@ _ly     ldy  #1                     ; modified
         stz  cx16.VERA_ADDR_L
         inc  cx16.VERA_ADDR_M       ; next line
         bra  _lx
-+       plx
-        rts
++       rts
 
 set_vera_textmatrix_addresses:
         stz  cx16.VERA_CTRL
@@ -90,11 +88,10 @@ set_vera_textmatrix_addresses:
         }}
 }
 
-asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
+asmsub  clear_screenchars (ubyte character @ A) clobbers(X, Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	%asm {{
-        phx
         pha
         jsr  cbm.SCREEN             ; get dimensions in X/Y
         txa
@@ -116,16 +113,14 @@ _lx     ldx  #0                     ; modified
         stz  cx16.VERA_ADDR_L
         inc  cx16.VERA_ADDR_M       ; next line
         bra  _lx
-+       plx
-        rts
++       rts
         }}
 }
 
-asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
+asmsub  clear_screencolors (ubyte color @ A) clobbers(X, Y)  {
 	; ---- clear the character screen colors with the given color (leaves characters).
 	;      (assumes color matrix is at the default address)
 	%asm {{
-        phx
         sta  _la+1
         jsr  cbm.SCREEN             ; get dimensions in X/Y
         txa
@@ -150,8 +145,7 @@ _la     lda  #0                     ; modified
         sta  cx16.VERA_ADDR_L
         inc  cx16.VERA_ADDR_M       ; next line
         bra  _lx
-+       plx
-        rts
++       rts
         }}
 }
 
@@ -192,11 +186,10 @@ sub iso_off() {
 }
 
 
-asmsub  scroll_left() clobbers(A, Y)  {
+asmsub  scroll_left() clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	%asm {{
-	    phx
 	    jsr  cbm.SCREEN
 	    dex
 	    stx  _lx+1
@@ -233,16 +226,14 @@ _lx     ldx  #0                ; modified
 
         lda  #0
         sta  cx16.VERA_CTRL
-	    plx
 	    rts
 	}}
 }
 
-asmsub  scroll_right() clobbers(A,Y)  {
+asmsub  scroll_right() clobbers(A,X,Y)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	%asm {{
-	    phx
 	    jsr  cbm.SCREEN
 	    dex
 	    stx  _lx+1
@@ -287,16 +278,14 @@ _lx     ldx  #0                 ; modified
 
         lda  #0
         sta  cx16.VERA_CTRL
-	    plx
 	    rts
 	}}
 }
 
-asmsub  scroll_up() clobbers(A, Y)  {
+asmsub  scroll_up() clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	%asm {{
-	    phx
 	    jsr  cbm.SCREEN
 	    stx  _nextline+1
 	    dey
@@ -337,16 +326,14 @@ _nextline
 
 +       lda  #0
         sta  cx16.VERA_CTRL
-	    plx
 	    rts
 	}}
 }
 
-asmsub  scroll_down() clobbers(A, Y)  {
+asmsub  scroll_down() clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	%asm {{
-	    phx
 	    jsr  cbm.SCREEN
 	    stx  _nextline+1
 	    dey
@@ -393,12 +380,11 @@ _nextline
 
 +       lda  #0
         sta  cx16.VERA_CTRL
-	    plx
 	    rts
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
 
 asmsub  print (str text @ AY) clobbers(A,Y)  {
 	; ---- print null terminated string from A/Y
@@ -418,10 +404,9 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		phx
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -429,16 +414,13 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		pla
 		jsr  cbm.CHROUT
 		txa
-		jsr  cbm.CHROUT
-		plx
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		phx
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -454,16 +436,13 @@ _print_byte_digits
         beq  _ones
         jsr  cbm.CHROUT
 _ones   txa
-		jsr  cbm.CHROUT
-		plx
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		phx
 		pha
 		cmp  #0
 		bpl  +
@@ -475,10 +454,9 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		phx
 		bcc  +
 		pha
 		lda  #'$'
@@ -487,16 +465,13 @@ asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  conv.ubyte2hex
 		jsr  cbm.CHROUT
 		tya
-		jsr  cbm.CHROUT
-		plx
-		rts
+		jmp  cbm.CHROUT
 	}}
 }
 
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		phx
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -509,12 +484,11 @@ asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,Y)  {
 +		jsr  cbm.CHROUT
 		dey
 		bne  -
-		plx
 		rts
 	}}
 }
 
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -526,7 +500,7 @@ asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -539,10 +513,9 @@ asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    phx
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -550,17 +523,14 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  cbm.CHROUT
 		iny
 		bne  -
-+		plx
-		rts
++		rts
 	}}
 }
 
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    phx
 		jsr  conv.uword2decimal
-		plx
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -581,7 +551,7 @@ _allzero
 	}}
 }
 
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -704,13 +674,12 @@ asmsub  getclr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
 	}}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor) {
 	; ---- set char+color at the given position on the screen
 	;      note: color handling is the same as on the C64: it only sets the foreground color and leaves the background color as is.
 	;            Use setcc2 if you want Cx-16 specific feature of setting both Bg+Fg colors (is faster as well).
 	%asm {{
-            phx
-            lda  column
+            lda  col
             asl  a
             tax
             ldy  row
@@ -722,7 +691,7 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
             ;clc
             adc  #>VERA_TEXTMATRIX_ADDR
             sta  cx16.VERA_ADDR_M
-            lda  char
+            lda  character
             sta  cx16.VERA_DATA0
             inc  cx16.VERA_ADDR_L
             lda  charcolor
@@ -732,18 +701,16 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
             and  #$f0
             ora  P8ZP_SCRATCH_B1
             sta  cx16.VERA_DATA0
-            plx
             rts
     }}
 }
 
-sub  setcc2  (ubyte column, ubyte row, ubyte char, ubyte colors)  {
+sub  setcc2  (ubyte col, ubyte row, ubyte character, ubyte colors)  {
 	; ---- set char+color at the given position on the screen
 	;      note: on the CommanderX16 this allows you to set both Fg and Bg colors;
 	;            use the high nybble in A to set the Bg color! Is a bit faster than setcc() too.
 	%asm {{
-            phx
-            lda  column
+            lda  col
             asl  a
             tax
             ldy  row
@@ -755,25 +722,19 @@ sub  setcc2  (ubyte column, ubyte row, ubyte char, ubyte colors)  {
             ; clc
             adc  #>VERA_TEXTMATRIX_ADDR
             sta  cx16.VERA_ADDR_M
-            lda  char
+            lda  character
             sta  cx16.VERA_DATA0
             inc  cx16.VERA_ADDR_L
             lda  colors
             sta  cx16.VERA_DATA0
-            plx
             rts
     }}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
-	; ---- safe wrapper around PLOT kernal routine, to save the X register.
+asmsub  plot  (ubyte col @ Y, ubyte row @ X) {
 	%asm  {{
-		phx
-		tax
 		clc
-		jsr  cbm.PLOT
-		plx
-		rts
+		jmp  cbm.PLOT
 	}}
 }
 

compiler/res/prog8lib/diskio.p8

@@ -42,12 +42,12 @@ diskio {
             ubyte high = cbm.CHRIN()
             txt.print_uw(mkword(high, low))
             txt.spc()
-            ubyte @zp char
+            ubyte @zp character
             repeat {
-                char = cbm.CHRIN()
-                if char==0
+                character = cbm.CHRIN()
+                if character==0
                     break
-                txt.chrout(char)
+                txt.chrout(character)
             }
             txt.nl()
             void cbm.CHRIN()     ; skip 2 bytes
@@ -211,12 +211,12 @@ io_error:
 
             ; read the filename
             repeat {
-                ubyte char = cbm.CHRIN()
-                if char==0
+                ubyte character = cbm.CHRIN()
+                if character==0
                     break
-                if char=='\"'
+                if character=='\"'
                     break
-                @(nameptr) = char
+                @(nameptr) = character
                 nameptr++
             }
 
@@ -444,24 +444,22 @@ io_error:
         goto done
     }
 
-    sub save(uword filenameptr, uword address, uword size) -> bool {
+    sub save(uword filenameptr, uword start_address, uword savesize) -> bool {
         cbm.SETNAM(string.length(filenameptr), filenameptr)
         cbm.SETLFS(1, drivenumber, 0)
-        uword @shared end_address = address + size
+        uword @shared end_address = start_address + savesize
         cx16.r0L = 0
 
         %asm {{
-            lda  address
+            lda  start_address
             sta  P8ZP_SCRATCH_W1
-            lda  address+1
+            lda  start_address+1
             sta  P8ZP_SCRATCH_W1+1
-            stx  P8ZP_SCRATCH_REG
             lda  #<P8ZP_SCRATCH_W1
             ldx  end_address
             ldy  end_address+1
             jsr  cbm.SAVE
             php
-            ldx  P8ZP_SCRATCH_REG
             plp
         }}
 
@@ -488,7 +486,6 @@ io_error:
             secondary = 0
         cbm.SETLFS(1, drivenumber, secondary)
         %asm {{
-            stx  P8ZP_SCRATCH_REG
             lda  #0
             ldx  address_override
             ldy  address_override+1
@@ -496,7 +493,7 @@ io_error:
             bcs  +
             stx  cx16.r1
             sty  cx16.r1+1
-+           ldx  P8ZP_SCRATCH_REG
++
         }}
 
         cbm.CLRCHN()
@@ -507,16 +504,16 @@ io_error:
     ; Identical to load(), but DOES INCLUDE the first 2 bytes in the file.
     ; No program header is assumed in the file. Everything is loaded.
     ; See comments on load() for more details.
-    sub load_raw(uword filenameptr, uword address) -> uword {
+    sub load_raw(uword filenameptr, uword start_address) -> uword {
         ; read the 2 header bytes separately to skip them
         if not f_open(filenameptr)
             return 0
-        cx16.r1 = f_read(address, 2)
+        cx16.r1 = f_read(start_address, 2)
         f_close()
         if cx16.r1!=2
             return 0
-        address += 2
-        return load(filenameptr, address)
+        start_address += 2
+        return load(filenameptr, start_address)
     }
 
     sub delete(uword filenameptr) {

compiler/res/prog8lib/floats_functions.p8

@@ -5,7 +5,6 @@ floats {
 sub print_f(float value) {
 	; ---- prints the floating point value (without a newline).
 	%asm {{
-		stx  floats_store_reg
 		lda  #<value
 		ldy  #>value
 		jsr  MOVFM		; load float into fac1
@@ -18,8 +17,7 @@ sub print_f(float value) {
 		jsr  cbm.CHROUT
 		iny
 		bne  -
-+		ldx  floats_store_reg
-		rts
++		rts
 	}}
 }
 
@@ -44,10 +42,7 @@ sub sin(float angle) -> float {
         lda  #<angle
         ldy  #>angle
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  SIN
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  SIN
     }}
 }
 
@@ -56,9 +51,7 @@ sub cos(float angle) -> float {
         lda  #<angle
         ldy  #>angle
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  COS
-        ldx  P8ZP_SCRATCH_REG
+        jmp  COS
         rts
     }}
 }
@@ -68,10 +61,7 @@ sub tan(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  TAN
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  TAN
     }}
 }
 
@@ -80,10 +70,7 @@ sub atan(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  ATN
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  ATN
     }}
 }
 
@@ -92,10 +79,7 @@ sub ln(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  LOG
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  LOG
     }}
 }
 
@@ -104,15 +88,12 @@ sub log2(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
         jsr  LOG
         jsr  MOVEF
         lda  #<FL_LOG2_const
         ldy  #>FL_LOG2_const
         jsr  MOVFM
-        jsr  FDIVT
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  FDIVT
     }}
 }
 
@@ -122,12 +103,9 @@ sub rad(float angle) -> float {
         lda  #<angle
         ldy  #>angle
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
         lda  #<_pi_div_180
         ldy  #>_pi_div_180
-        jsr  FMULT
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  FMULT
 _pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
     }}
 }
@@ -138,11 +116,9 @@ sub deg(float angle) -> float {
         lda  #<angle
         ldy  #>angle
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
         lda  #<_one_over_pi_div_180
         ldy  #>_one_over_pi_div_180
-        jsr  FMULT
-        ldx  P8ZP_SCRATCH_REG
+        jmp  FMULT
         rts
 _one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
     }}
@@ -153,11 +129,8 @@ sub round(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
         jsr  FADDH
-        jsr  INT
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  INT
     }}
 }
 
@@ -166,10 +139,7 @@ sub floor(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
-        jsr  INT
-        ldx  P8ZP_SCRATCH_REG
-        rts
+        jmp  INT
     }}
 }
 
@@ -179,7 +149,6 @@ sub ceil(float value) -> float {
         lda  #<value
         ldy  #>value
         jsr  MOVFM
-        stx  P8ZP_SCRATCH_REG
         ldx  #<fmath_float1
         ldy  #>fmath_float1
         jsr  MOVMF
@@ -192,8 +161,7 @@ sub ceil(float value) -> float {
         lda  #<FL_ONE_const
         ldy  #>FL_ONE_const
         jsr  FADD
-+       ldx  P8ZP_SCRATCH_REG
-        rts
++       rts
     }}
 }
 
@@ -202,14 +170,11 @@ sub rndseedf(float seed) {
         seed = -seed    ; make sure fp seed is always negative
 
     %asm {{
-        stx  floats_store_reg
         lda  #<seed
         ldy  #>seed
         jsr  MOVFM		; load float into fac1
         lda  #-1
-        jsr  floats.RND
-        ldx  floats_store_reg
-        rts
+        jmp  floats.RND
     }}
 }
 

compiler/res/prog8lib/pet32/syslib.p8

@@ -0,0 +1,452 @@
+; Prog8 definitions for the Commodore PET
+; Including memory registers, I/O registers, Basic and Kernal subroutines.
+; see: https://www.pagetable.com/?p=926  ,  http://www.zimmers.net/cbmpics/cbm/PETx/petmem.txt
+
+cbm {
+    ; Commodore (CBM) common variables, vectors and kernal routines
+    %option no_symbol_prefixing
+
+        &ubyte  TIME_HI         = $8d       ; software jiffy clock, hi byte
+        &ubyte  TIME_MID        = $8e       ;  .. mid byte
+        &ubyte  TIME_LO         = $8f       ;    .. lo byte. Updated by IRQ every 1/60 sec
+        &ubyte  STATUS          = $96       ; kernal status variable for I/O
+
+        &uword  CINV            = $0090     ; IRQ vector (in ram)
+        &uword  CBINV           = $0092     ; BRK vector (in ram)
+        &uword  NMINV           = $0094     ; NMI vector (in ram)
+
+        &uword  NMI_VEC         = $FFFA     ; 6502 nmi vector, determined by the kernal if banked in
+        &uword  RESET_VEC       = $FFFC     ; 6502 reset vector, determined by the kernal if banked in
+        &uword  IRQ_VEC         = $FFFE     ; 6502 interrupt vector, determined by the kernal if banked in
+
+        ; the default addresses for the character screen chars and colors
+        const  uword  Screen    = $8000     ; to have this as an array[40*25] the compiler would have to support array size > 255
+
+
+romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc    ; define an input channel
+romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; define an output channel
+romsub $FFCC = CLRCHN() clobbers(A,X)                           ; restore default devices
+romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A              ; input a character (for keyboard, read a whole line from the screen) A=byte read.
+romsub $FFD2 = CHROUT(ubyte character @ A)                           ; output a character
+romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; check the STOP key (and some others in A)
+romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; get a character
+romsub $FFE7 = CLALL() clobbers(A,X)                            ; close all files
+romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
+
+asmsub STOP2() clobbers(X) -> ubyte @A  {
+    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+    %asm {{
+        jsr  cbm.STOP
+        beq  +
+        lda  #0
+        rts
++       lda  #1
+        rts
+    }}
+}
+
+asmsub SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y) {
+    ; PET stub to set the software clock
+    %asm {{
+        sty  TIME_HI
+        stx  TIME_MID
+        sta  TIME_LO
+        rts
+    }}
+}
+
+asmsub RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y {
+    ; PET stub to read the software clock (A=lo,X=mid,Y=high)
+    %asm {{
+        ldy  TIME_HI
+        ldx  TIME_MID
+        lda  TIME_LO
+        rts
+    }}
+}
+
+asmsub RDTIM16() clobbers(X) -> uword @AY {
+    ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience
+    %asm {{
+        lda  TIME_LO
+        ldy  TIME_MID
+        rts
+    }}
+}
+
+
+}
+
+sys {
+    ; ------- lowlevel system routines --------
+    %option no_symbol_prefixing
+
+    const ubyte target = 32         ;  compilation target specifier.  64 = C64, 128 = C128,  16 = CommanderX16, 32=PET
+
+asmsub  init_system()  {
+    ; Initializes the machine to a sane starting state.
+    ; Called automatically by the loader program logic.
+    ; Uppercase charset is activated.
+    %asm {{
+        sei
+        cld
+        lda  #142
+        jsr  cbm.CHROUT     ; uppercase
+        lda  #147
+        jsr  cbm.CHROUT     ; clear screen
+        clc
+        clv
+        cli
+        rts
+    }}
+}
+
+asmsub  init_system_phase2()  {
+    %asm {{
+        rts     ; no phase 2 steps on the PET
+    }}
+}
+
+asmsub  cleanup_at_exit() {
+    ; executed when the main subroutine does rts
+    %asm {{
+        rts
+    }}
+}
+
+    asmsub  reset_system()  {
+        ; Soft-reset the system back to initial power-on Basic prompt.
+        %asm {{
+            sei
+            jmp  (cbm.RESET_VEC)
+        }}
+    }
+
+    asmsub waitvsync() clobbers(A) {
+        ; --- busy wait till the next vsync has occurred (approximately), without depending on custom irq handling.
+        ;     Note: on PET this simply waits until the next jiffy clock update, I don't know if a true vsync is possible there
+        %asm {{
+            lda  #1
+            ldy  #0
+            jmp  wait
+        }}
+    }
+
+    asmsub wait(uword jiffies @AY) {
+        ; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
+        ;     note: the system irq handler has to be active for this to work as it depends on the system jiffy clock
+        %asm {{
+            stx  P8ZP_SCRATCH_B1
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+
+_loop       lda  P8ZP_SCRATCH_W1
+            ora  P8ZP_SCRATCH_W1+1
+            bne  +
+            ldx  P8ZP_SCRATCH_B1
+            rts
+
++           lda  cbm.TIME_LO
+            sta  P8ZP_SCRATCH_B1
+-           lda  cbm.TIME_LO
+            cmp  P8ZP_SCRATCH_B1
+            beq  -
+
+            lda  P8ZP_SCRATCH_W1
+            bne  +
+            dec  P8ZP_SCRATCH_W1+1
++           dec  P8ZP_SCRATCH_W1
+            jmp  _loop
+        }}
+    }
+
+    asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
+        ; Called when the compiler wants to assign a string value to another string.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
+    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
+        ; note: only works for NON-OVERLAPPING memory regions!
+        ; note: can't be inlined because is called from asm as well
+        %asm {{
+            ldx  cx16.r0
+            stx  P8ZP_SCRATCH_W1        ; source in ZP
+            ldx  cx16.r0+1
+            stx  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            stx  P8ZP_SCRATCH_W2        ; target in ZP
+            ldx  cx16.r1+1
+            stx  P8ZP_SCRATCH_W2+1
+            cpy  #0
+            bne  _longcopy
+
+            ; copy <= 255 bytes
+            tay
+            bne  _copyshort
+            rts     ; nothing to copy
+
+_copyshort
+            ; decrease source and target pointers so we can simply index by Y
+            lda  P8ZP_SCRATCH_W1
+            bne  +
+            dec  P8ZP_SCRATCH_W1+1
++           dec  P8ZP_SCRATCH_W1
+            lda  P8ZP_SCRATCH_W2
+            bne  +
+            dec  P8ZP_SCRATCH_W2+1
++           dec  P8ZP_SCRATCH_W2
+
+-           lda  (P8ZP_SCRATCH_W1),y
+            sta  (P8ZP_SCRATCH_W2),y
+            dey
+            bne  -
+            rts
+
+_longcopy
+            sta  P8ZP_SCRATCH_B1        ; lsb(count) = remainder in last page
+            tya
+            tax                         ; x = num pages (1+)
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            sta  (P8ZP_SCRATCH_W2),y
+            iny
+            bne  -
+            inc  P8ZP_SCRATCH_W1+1
+            inc  P8ZP_SCRATCH_W2+1
+            dex
+            bne  -
+            ldy  P8ZP_SCRATCH_B1
+            bne  _copyshort
+            rts
+        }}
+    }
+
+    asmsub memset(uword mem @R0, uword numbytes @R1, ubyte value @A) clobbers(A,X,Y) {
+        %asm {{
+            ldy  cx16.r0
+            sty  P8ZP_SCRATCH_W1
+            ldy  cx16.r0+1
+            sty  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            ldy  cx16.r1+1
+            jmp  prog8_lib.memset
+        }}
+    }
+
+    asmsub memsetw(uword mem @R0, uword numwords @R1, uword value @AY) clobbers(A,X,Y) {
+        %asm {{
+            ldx  cx16.r0
+            stx  P8ZP_SCRATCH_W1
+            ldx  cx16.r0+1
+            stx  P8ZP_SCRATCH_W1+1
+            ldx  cx16.r1
+            stx  P8ZP_SCRATCH_W2
+            ldx  cx16.r1+1
+            stx  P8ZP_SCRATCH_W2+1
+            jmp  prog8_lib.memsetw
+        }}
+    }
+
+    inline asmsub read_flags() -> ubyte @A {
+        %asm {{
+        php
+        pla
+        }}
+    }
+
+    inline asmsub clear_carry() {
+        %asm {{
+        clc
+        }}
+    }
+
+    inline asmsub set_carry() {
+        %asm {{
+        sec
+        }}
+    }
+
+    inline asmsub clear_irqd() {
+        %asm {{
+        cli
+        }}
+    }
+
+    inline asmsub set_irqd() {
+        %asm {{
+        sei
+        }}
+    }
+
+    inline asmsub irqsafe_set_irqd() {
+        %asm {{
+        php
+        sei
+        }}
+    }
+
+    inline asmsub irqsafe_clear_irqd() {
+        %asm {{
+        plp
+        }}
+    }
+
+    inline asmsub exit(ubyte returnvalue @A) {
+        ; -- immediately exit the program with a return code in the A register
+        %asm {{
+            ldx  prog8_lib.orig_stackpointer
+            txs
+            rts		; return to original caller
+        }}
+    }
+
+    inline asmsub progend() -> uword @AY {
+        %asm {{
+            lda  #<prog8_program_end
+            ldy  #>prog8_program_end
+        }}
+    }
+
+}
+
+cx16 {
+    %option no_symbol_prefixing
+
+    ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
+    ; they are simulated on the PET as well but their location in memory is different
+    ; (because there's no room for them in the zeropage)
+    ; we select the top page of RAM (assume 32Kb)
+    &uword r0  = $7fe0
+    &uword r1  = $7fe2
+    &uword r2  = $7fe4
+    &uword r3  = $7fe6
+    &uword r4  = $7fe8
+    &uword r5  = $7fea
+    &uword r6  = $7fec
+    &uword r7  = $7fee
+    &uword r8  = $7ff0
+    &uword r9  = $7ff2
+    &uword r10 = $7ff4
+    &uword r11 = $7ff6
+    &uword r12 = $7ff8
+    &uword r13 = $7ffa
+    &uword r14 = $7ffc
+    &uword r15 = $7ffe
+
+    &word r0s  = $7fe0
+    &word r1s  = $7fe2
+    &word r2s  = $7fe4
+    &word r3s  = $7fe6
+    &word r4s  = $7fe8
+    &word r5s  = $7fea
+    &word r6s  = $7fec
+    &word r7s  = $7fee
+    &word r8s  = $7ff0
+    &word r9s  = $7ff2
+    &word r10s = $7ff4
+    &word r11s = $7ff6
+    &word r12s = $7ff8
+    &word r13s = $7ffa
+    &word r14s = $7ffc
+    &word r15s = $7ffe
+
+    &ubyte r0L  = $7fe0
+    &ubyte r1L  = $7fe2
+    &ubyte r2L  = $7fe4
+    &ubyte r3L  = $7fe6
+    &ubyte r4L  = $7fe8
+    &ubyte r5L  = $7fea
+    &ubyte r6L  = $7fec
+    &ubyte r7L  = $7fee
+    &ubyte r8L  = $7ff0
+    &ubyte r9L  = $7ff2
+    &ubyte r10L = $7ff4
+    &ubyte r11L = $7ff6
+    &ubyte r12L = $7ff8
+    &ubyte r13L = $7ffa
+    &ubyte r14L = $7ffc
+    &ubyte r15L = $7ffe
+
+    &ubyte r0H  = $7fe1
+    &ubyte r1H  = $7fe3
+    &ubyte r2H  = $7fe5
+    &ubyte r3H  = $7fe7
+    &ubyte r4H  = $7fe9
+    &ubyte r5H  = $7feb
+    &ubyte r6H  = $7fed
+    &ubyte r7H  = $7fef
+    &ubyte r8H  = $7ff1
+    &ubyte r9H  = $7ff3
+    &ubyte r10H = $7ff5
+    &ubyte r11H = $7ff7
+    &ubyte r12H = $7ff9
+    &ubyte r13H = $7ffb
+    &ubyte r14H = $7ffd
+    &ubyte r15H = $7fff
+
+    &byte r0sL  = $7fe0
+    &byte r1sL  = $7fe2
+    &byte r2sL  = $7fe4
+    &byte r3sL  = $7fe6
+    &byte r4sL  = $7fe8
+    &byte r5sL  = $7fea
+    &byte r6sL  = $7fec
+    &byte r7sL  = $7fee
+    &byte r8sL  = $7ff0
+    &byte r9sL  = $7ff2
+    &byte r10sL = $7ff4
+    &byte r11sL = $7ff6
+    &byte r12sL = $7ff8
+    &byte r13sL = $7ffa
+    &byte r14sL = $7ffc
+    &byte r15sL = $7ffe
+
+    &byte r0sH  = $7fe1
+    &byte r1sH  = $7fe3
+    &byte r2sH  = $7fe5
+    &byte r3sH  = $7fe7
+    &byte r4sH  = $7fe9
+    &byte r5sH  = $7feb
+    &byte r6sH  = $7fed
+    &byte r7sH  = $7fef
+    &byte r8sH  = $7ff1
+    &byte r9sH  = $7ff3
+    &byte r10sH = $7ff5
+    &byte r11sH = $7ff7
+    &byte r12sH = $7ff9
+    &byte r13sH = $7ffb
+    &byte r14sH = $7ffd
+    &byte r15sH = $7fff
+
+    asmsub save_virtual_registers() clobbers(A,Y) {
+        %asm {{
+            ldy  #31
+    -       lda  cx16.r0,y
+            sta  _cx16_vreg_storage,y
+            dey
+            bpl  -
+            rts
+
+    _cx16_vreg_storage
+            .word 0,0,0,0,0,0,0,0
+            .word 0,0,0,0,0,0,0,0
+        }}
+    }
+
+    asmsub restore_virtual_registers() clobbers(A,Y) {
+        %asm {{
+            ldy  #31
+    -       lda  save_virtual_registers._cx16_vreg_storage,y
+            sta  cx16.r0,y
+            dey
+            bpl  -
+            rts
+        }}
+    }
+}

compiler/res/prog8lib/pet32/textio.p8

@@ -0,0 +1,456 @@
+; Prog8 definitions for the Text I/O and Screen routines for the Commodore PET
+
+%import syslib
+%import conv
+
+
+txt {
+    %option no_symbol_prefixing
+
+const ubyte DEFAULT_WIDTH = 40
+const ubyte DEFAULT_HEIGHT = 25
+
+
+sub  clear_screen() {
+    txt.chrout(147)
+}
+
+sub home() {
+    txt.chrout(19)
+}
+
+sub nl() {
+    txt.chrout('\n')
+}
+
+sub spc() {
+    txt.chrout(' ')
+}
+
+
+asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
+	; ---- fill the character screen with the given fill character. color is ignored on PET
+	%asm {{
+		jmp  clear_screenchars
+        }}
+
+}
+
+asmsub  clear_screenchars (ubyte character @ A) clobbers(Y)  {
+	; ---- clear the character screen with the given fill character
+	;      (assumes screen matrix is at the default address)
+	%asm {{
+		ldy  #250
+-		sta  cbm.Screen+250*0-1,y
+		sta  cbm.Screen+250*1-1,y
+		sta  cbm.Screen+250*2-1,y
+		sta  cbm.Screen+250*3-1,y
+		dey
+		bne  -
+		rts
+        }}
+}
+
+sub  clear_screencolors (ubyte color)  {
+    ; --- dummy function on PET
+}
+
+sub color (ubyte txtcol) {
+    ; --- dummy function on PET
+}
+
+
+sub lowercase() {
+    txt.chrout(14)
+}
+
+sub uppercase() {
+    txt.chrout(142)
+}
+
+asmsub  scroll_left  () clobbers(A, X, Y)  {
+	; ---- scroll the whole screen 1 character to the left
+	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
+
+	%asm {{
+		ldx  #0
+		ldy  #38
+-
+        .for row=0, row<=24, row+=1
+            lda  cbm.Screen + 40*row + 1,x
+            sta  cbm.Screen + 40*row + 0,x
+        .next
+		inx
+		dey
+		bpl  -
+
+		rts
+	}}
+}
+
+asmsub  scroll_right  () clobbers(A,X)  {
+	; ---- scroll the whole screen 1 character to the right
+	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
+	%asm {{
+		ldx  #38
+-
+        .for row=0, row<=24, row+=1
+            lda  cbm.Screen + 40*row + 0,x
+            sta  cbm.Screen + 40*row + 1,x
+        .next
+		dex
+		bpl  -
+
+		rts
+	}}
+}
+
+asmsub  scroll_up  () clobbers(A,X)  {
+	; ---- scroll the whole screen 1 character up
+	;      contents of the bottom row are unchanged, you should refill/clear this yourself
+	%asm {{
+		ldx #39
+-
+        .for row=1, row<=24, row+=1
+            lda  cbm.Screen + 40*row,x
+            sta  cbm.Screen + 40*(row-1),x
+        .next
+		dex
+		bpl  -
+
+		rts
+	}}
+}
+
+asmsub  scroll_down  () clobbers(A,X)  {
+	; ---- scroll the whole screen 1 character down
+	;      contents of the top row are unchanged, you should refill/clear this yourself
+	%asm {{
+		ldx #39
+-
+        .for row=23, row>=0, row-=1
+            lda  cbm.Screen + 40*row,x
+            sta  cbm.Screen + 40*(row+1),x
+        .next
+		dex
+		bpl  -
+
+		rts
+	}}
+}
+
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+
+asmsub  print (str text @ AY) clobbers(A,Y)  {
+	; ---- print null terminated string from A/Y
+	; note: the compiler contains an optimization that will replace
+	;       a call to this subroutine with a string argument of just one char,
+	;       by just one call to cbm.CHROUT of that single char.
+	%asm {{
+		sta  P8ZP_SCRATCH_B1
+		sty  P8ZP_SCRATCH_REG
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_B1),y
+		beq  +
+		jsr  cbm.CHROUT
+		iny
+		bne  -
++		rts
+	}}
+}
+
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
+	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
+	%asm {{
+		jsr  conv.ubyte2decimal
+		pha
+		tya
+		jsr  cbm.CHROUT
+		pla
+		jsr  cbm.CHROUT
+		txa
+		jmp  cbm.CHROUT
+	}}
+}
+
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
+	; ---- print the ubyte in A in decimal form, without left padding 0s
+	%asm {{
+		jsr  conv.ubyte2decimal
+_print_byte_digits
+		pha
+		cpy  #'0'
+		beq  +
+		tya
+		jsr  cbm.CHROUT
+		pla
+		jsr  cbm.CHROUT
+		jmp  _ones
++       pla
+        cmp  #'0'
+        beq  _ones
+        jsr  cbm.CHROUT
+_ones   txa
+		jmp  cbm.CHROUT
+	}}
+}
+
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
+	; ---- print the byte in A in decimal form, without left padding 0s
+	%asm {{
+		pha
+		cmp  #0
+		bpl  +
+		lda  #'-'
+		jsr  cbm.CHROUT
++		pla
+		jsr  conv.byte2decimal
+		jmp  print_ub._print_byte_digits
+	}}
+}
+
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
+	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
+	%asm {{
+		bcc  +
+		pha
+		lda  #'$'
+		jsr  cbm.CHROUT
+		pla
++		jsr  conv.ubyte2hex
+		jsr  cbm.CHROUT
+		tya
+		jmp  cbm.CHROUT
+	}}
+}
+
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
+	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
+	%asm {{
+		sta  P8ZP_SCRATCH_B1
+		bcc  +
+		lda  #'%'
+		jsr  cbm.CHROUT
++		ldy  #8
+-		lda  #'0'
+		asl  P8ZP_SCRATCH_B1
+		bcc  +
+		lda  #'1'
++		jsr  cbm.CHROUT
+		dey
+		bne  -
+		rts
+	}}
+}
+
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
+	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
+	%asm {{
+		pha
+		tya
+		jsr  print_ubbin
+		pla
+		clc
+		jmp  print_ubbin
+	}}
+}
+
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
+	; ---- print the uword in A/Y in hexadecimal form (4 digits)
+	;      (if Carry is set, a radix prefix '$' is printed as well)
+	%asm {{
+		pha
+		tya
+		jsr  print_ubhex
+		pla
+		clc
+		jmp  print_ubhex
+	}}
+}
+
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
+	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
+	%asm {{
+		jsr  conv.uword2decimal
+		ldy  #0
+-		lda  conv.uword2decimal.decTenThousands,y
+        beq  +
+		jsr  cbm.CHROUT
+		iny
+		bne  -
++		rts
+	}}
+}
+
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
+	; ---- print the uword in A/Y in decimal form, without left padding 0s
+	%asm {{
+		jsr  conv.uword2decimal
+		ldy  #0
+-		lda  conv.uword2decimal.decTenThousands,y
+		beq  _allzero
+		cmp  #'0'
+		bne  _gotdigit
+		iny
+		bne  -
+
+_gotdigit
+		jsr  cbm.CHROUT
+		iny
+		lda  conv.uword2decimal.decTenThousands,y
+		bne  _gotdigit
+		rts
+_allzero
+        lda  #'0'
+        jmp  cbm.CHROUT
+	}}
+}
+
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
+	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
+	%asm {{
+		cpy  #0
+		bpl  +
+		pha
+		lda  #'-'
+		jsr  cbm.CHROUT
+		tya
+		eor  #255
+		tay
+		pla
+		eor  #255
+		clc
+		adc  #1
+		bcc  +
+		iny
++		jmp  print_uw
+	}}
+}
+
+asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
+	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	;      It assumes the keyboard is selected as I/O channel!
+
+	%asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0				; char counter = 0
+-		jsr  cbm.CHRIN
+		cmp  #$0d			; return (ascii 13) pressed?
+		beq  +				; yes, end.
+		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
+		iny
+		bne  -
++		lda  #0
+		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
+		rts
+
+	}}
+}
+
+asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)  {
+	; ---- sets the character in the screen matrix at the given position
+	%asm {{
+		pha
+		tya
+		asl  a
+		tay
+		lda  _screenrows+1,y
+		sta  _mod+2
+		txa
+		clc
+		adc  _screenrows,y
+		sta  _mod+1
+		bcc  +
+		inc  _mod+2
++		pla
+_mod		sta  $ffff		; modified
+		rts
+
+_screenrows	.word  cbm.Screen + range(0, 1000, 40)
+	}}
+}
+
+asmsub  getchr  (ubyte col @A, ubyte row @Y) clobbers(Y) -> ubyte @ A {
+	; ---- get the character in the screen matrix at the given location
+	%asm  {{
+		pha
+		tya
+		asl  a
+		tay
+		lda  setchr._screenrows+1,y
+		sta  _mod+2
+		pla
+		clc
+		adc  setchr._screenrows,y
+		sta  _mod+1
+		bcc  _mod
+		inc  _mod+2
+_mod		lda  $ffff		; modified
+		rts
+	}}
+}
+
+sub  setclr  (ubyte col, ubyte row, ubyte color)  {
+    ; --- dummy function on PET
+}
+
+
+sub  setcc  (ubyte col, ubyte row, ubyte character, ubyte charcolor)  {
+	; ---- set char at the given position on the screen. charcolor is ignored on PET
+	%asm {{
+  		lda  row
+		asl  a
+		tay
+		lda  setchr._screenrows+1,y
+		sta  _charmod+2
+		lda  setchr._screenrows,y
+		clc
+		adc  col
+		sta  _charmod+1
+		bcc  +
+		inc  _charmod+2
++		lda  character
+_charmod	sta  $ffff		; modified
+		rts
+	}}
+}
+
+asmsub  plot  (ubyte col @ Y, ubyte row @ X) {
+	%asm  {{
+	    jsr  home
+	    cpy  #0
+	    beq  +
+-	    lda  #17
+	    jsr  chrout
+	    dey
+	    bne  -
++	    cpx  #0
+	    beq  +
+-       lda  #29
+        jsr  chrout
+        dex
+        bne  -
++		rts
+	}}
+}
+
+asmsub width() clobbers(X,Y) -> ubyte @A {
+    ; -- returns the text screen width (number of columns)
+    %asm {{
+        lda  $d5
+        clc
+        adc  #1
+        rts
+    }}
+}
+
+asmsub height() clobbers(X, Y) -> ubyte @A {
+    ; -- returns the text screen height (number of rows)
+    %asm {{
+        lda  #25
+        rts
+    }}
+}
+
+}

compiler/res/prog8lib/prog8_funcs.asm

@@ -1,20 +1,6 @@
 ; ---- builtin functions
 
 
-func_any_b_stack	.proc
-		jsr  func_any_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_all_b_stack	.proc
-		jsr  func_all_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_any_b_into_A	.proc
 		; -- any(array),  array in P8ZP_SCRATCH_W1, num bytes in A
 		sta  _cmp_mod+1		; self-modifying code
@@ -49,14 +35,6 @@ func_any_w_into_A	.proc
 		jmp  func_any_b_into_A
 		.pend
 
-func_any_w_stack	.proc
-		asl  a
-		jsr  func_any_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_all_w_into_A	.proc
 		; -- all(warray),  array in P8ZP_SCRATCH_W1, num bytes in A
 		asl  a			; times 2 because of word
@@ -77,22 +55,6 @@ _cmp_mod	cpy  #255		; modified
 		rts
 		.pend
 
-func_all_w_stack	.proc
-		jsr  func_all_w_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-abs_b_stack	.proc
-	; -- push abs(A) on stack (as unsigned word)
-		jsr  abs_b_into_A
-		sta  P8ESTACK_LO,x
-		stz  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
 abs_b_into_A	.proc
 	; -- A = abs(A)
 		cmp  #0
@@ -104,16 +66,6 @@ abs_b_into_A	.proc
 		rts
 		.pend
 
-abs_w_stack	.proc
-	; -- push abs(AY) on stack (as word)
-		jsr  abs_w_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
 abs_w_into_AY	.proc
 	; -- AY = abs(AY)
 		cpy  #0
@@ -142,13 +94,6 @@ _neg		lda  #-1
 		rts
 		.pend
 
-func_sign_b_stack	.proc
-		jsr  func_sign_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_ub_into_A	.proc
 		cmp  #0
 		bne  _pos
@@ -157,13 +102,6 @@ _pos		lda  #1
 		rts
 		.pend
 
-func_sign_ub_stack	.proc
-		jsr  func_sign_ub_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_uw_into_A	.proc
 		cpy  #0
 		beq  _possibly_zero
@@ -174,13 +112,6 @@ _possibly_zero	cmp  #0
 		rts
 		.pend
 
-func_sign_uw_stack	.proc
-		jsr  func_sign_uw_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sign_w_into_A	.proc
 		cpy  #0
 		beq  _possibly_zero
@@ -195,52 +126,43 @@ _possibly_zero	cmp  #0
 		.pend
 
 
-func_sign_w_stack	.proc
-		jsr  func_sign_w_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sqrt16_stack	.proc
-		jsr  func_sqrt16_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
 func_sqrt16_into_A	.proc
-		; integer square root from  http://6502org.wikidot.com/software-math-sqrt
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		txa
-		pha
-		lda  #0
-		sta  P8ZP_SCRATCH_B1
-		sta  P8ZP_SCRATCH_REG
-		ldx  #8
--		sec
-		lda  P8ZP_SCRATCH_W1+1
-		sbc  #$40
-		tay
-		lda  P8ZP_SCRATCH_REG
-		sbc  P8ZP_SCRATCH_B1
-		bcc  +
-		sty  P8ZP_SCRATCH_W1+1
-		sta  P8ZP_SCRATCH_REG
-+		rol  P8ZP_SCRATCH_B1
-		asl  P8ZP_SCRATCH_W1
-		rol  P8ZP_SCRATCH_W1+1
-		rol  P8ZP_SCRATCH_REG
-		asl  P8ZP_SCRATCH_W1
-		rol  P8ZP_SCRATCH_W1+1
-		rol  P8ZP_SCRATCH_REG
-		dex
-		bne  -
-		pla
-		tax
-		lda  P8ZP_SCRATCH_B1
-		rts
+		; integer square root
+		; http://6502org.wikidot.com/software-math-sqrt
+		; https://github.com/TobyLobster/sqrt_test/blob/main/sqrt/sqrt7.a
+		; Tweaked by TobyLobster and 0xC0DE to be smaller and faster
+_numl = P8ZP_SCRATCH_W1
+_numh = P8ZP_SCRATCH_W1+1
+_loop_counter = P8ZP_SCRATCH_REG
+_root = P8ZP_SCRATCH_B1
+            sta  _numl
+            sty  _numh
+            ldx  #$ff
+            stx  _loop_counter
+            inx
+            stx  _root
+            sec
+_loop       lda  _numh
+            sbc  #$40
+            tay
+            txa
+            sbc  _root
+            bcc  +
+            sty  _numh
+            bcs  ++
++           txa
++           rol  _root
+            asl  _numl
+            rol  _numh
+            rol  a
+            asl  _numl
+            rol  _numh
+            rol  a
+            tax
+            lsr  _loop_counter
+            bne  _loop
+            lda  _root
+            rts
 		.pend
 
 

compiler/res/prog8lib/prog8_lib.asm

@@ -4,10 +4,8 @@
 
 orig_stackpointer	.byte  0	; stores the Stack pointer register at program start
 
-read_byte_from_address_on_stack	.proc
-	; -- read the byte from the memory address on the top of the stack, return in A (stack remains unchanged)
-		lda  P8ESTACK_LO+1,x
-		ldy  P8ESTACK_HI+1,x
+
+read_byte_from_address_in_AY_into_A	.proc
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
@@ -16,318 +14,16 @@ read_byte_from_address_on_stack	.proc
 		.pend
 
 
-write_byte_to_address_on_stack	.proc
-	; -- write the byte in A to the memory address on the top of the stack (stack remains unchanged)
-		ldy  P8ESTACK_LO+1,x
-		sty  P8ZP_SCRATCH_W2
-		ldy  P8ESTACK_HI+1,x
+write_byte_X_to_address_in_AY	.proc
+		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
+		txa
 		sta  (P8ZP_SCRATCH_W2),y
 		rts
 		.pend
 
 
-
-neg_b		.proc
-		lda  #0
-		sec
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-neg_w		.proc
-		sec
-		lda  #0
-		sbc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  #0
-		sbc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-inv_word	.proc
-		lda  P8ESTACK_LO+1,x
-		eor  #255
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+1,x
-		eor  #255
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-bitand_b	.proc
-		; -- bitwise and (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		and  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitor_b		.proc
-		; -- bitwise or (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitxor_b	.proc
-		; -- bitwise xor (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		eor  P8ESTACK_LO+1,x
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-bitand_w	.proc
-		; -- bitwise and (of 2 words)
-		lda  P8ESTACK_LO+2,x
-		and  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		and  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-bitor_w		.proc
-		; -- bitwise or (of 2 words)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		ora  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-bitxor_w	.proc
-		; -- bitwise xor (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		eor  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+2,x
-		eor  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+2,x
-		inx
-		rts
-		.pend
-
-
-add_w		.proc
-	; -- push word+word / uword+uword
-		inx
-		clc
-		lda  P8ESTACK_LO,x
-		adc  P8ESTACK_LO+1,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI,x
-		adc  P8ESTACK_HI+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-sub_w		.proc
-	; -- push word-word
-		inx
-		sec
-		lda  P8ESTACK_LO+1,x
-		sbc  P8ESTACK_LO,x
-		sta  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-mul_byte	.proc
-	; -- b*b->b (signed and unsigned)
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_LO+1,x
-		jsr  math.multiply_bytes
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-mul_word	.proc
-		inx
-		lda  P8ESTACK_LO,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO+1,x
-		ldy  P8ESTACK_HI+1,x
-		jsr  math.multiply_words
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-idiv_b		.proc
-	; signed division: use unsigned division and fix sign of result afterwards
-		inx
-		lda  P8ESTACK_LO,x
-		eor  P8ESTACK_LO+1,x
-		php			; save sign of result
-		lda  P8ESTACK_LO,x
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; make num1 positive
-+		tay
-		inx
-		lda  P8ESTACK_LO,x
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; make num2 positive
-+		jsr  math.divmod_ub_asm
-		sta  _remainder
-		tya
-		plp			; get sign of result
-		bpl  +
-		eor  #$ff
-		sec
-		adc  #0			; negate result
-+		sta  P8ESTACK_LO,x
-		dex
-		rts
-_remainder	.byte  0
-		.pend
-
-idiv_ub		.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		lda  P8ESTACK_LO+1,x
-		jsr  math.divmod_ub_asm
-		tya
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-idiv_w		.proc
-	; signed division: use unsigned division and fix sign of result afterwards
-		lda  P8ESTACK_HI+2,x
-		eor  P8ESTACK_HI+1,x
-		php				; save sign of result
-		lda  P8ESTACK_HI+1,x
-		bpl  +
-		jsr  neg_w			; make value positive
-+		inx
-		lda  P8ESTACK_HI+1,x
-		bpl  +
-		jsr  neg_w			; make value positive
-+		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		plp
-		bpl  +
-		jmp  neg_w		; negate result
-+		rts
-		.pend
-
-idiv_uw		.proc
-		inx
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		sta  P8ESTACK_LO+1,x
-		tya
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-remainder_ub	.proc
-		inx
-		ldy  P8ESTACK_LO,x	; right operand
-		lda  P8ESTACK_LO+1,x  ; left operand
-		jsr  math.divmod_ub_asm
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-remainder_uw	.proc
-		inx
-		lda  P8ESTACK_LO+1,x
-		sta  P8ZP_SCRATCH_W1
-		lda  P8ESTACK_HI+1,x
-		sta  P8ZP_SCRATCH_W1+1
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jsr  math.divmod_uw_asm
-		lda  P8ZP_SCRATCH_W2
-		sta  P8ESTACK_LO+1,x
-		lda  P8ZP_SCRATCH_W2+1
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-equal_w		.proc
-	; -- are the two words on the stack identical?
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bne  equal_b._equal_b_false
-		beq  equal_b._equal_b_true
-		.pend
-
-notequal_b	.proc
-	; -- are the two bytes on the stack different?
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		beq  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		.pend
-
-notequal_w	.proc
-	; -- are the two words on the stack different?
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		beq  notequal_b
-		bne  equal_b._equal_b_true
-		.pend
-
-less_ub		.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
-less_b		.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		sec
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
 reg_less_uw	.proc
 		;  AY < P8ZP_SCRATCH_W2?
 		cpy  P8ZP_SCRATCH_W2+1
@@ -341,17 +37,6 @@ _true		lda  #1
 		rts
 		.pend
 
-less_uw		.proc
-		lda  P8ESTACK_HI+2,x
-		cmp  P8ESTACK_HI+1,x
-		bcc  equal_b._equal_b_true
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
 reg_less_w	.proc
 		; -- AY < P8ZP_SCRATCH_W2?
 		cmp  P8ZP_SCRATCH_W2
@@ -366,48 +51,6 @@ _true		lda  #1
 		rts
 		.pend
 
-less_w		.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+2,x
-		sbc  P8ESTACK_HI+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
-equal_b		.proc
-	; -- are the two bytes on the stack identical?
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bne  _equal_b_false
-_equal_b_true	lda  #1
-_equal_b_store	inx
-		sta  P8ESTACK_LO+1,x
-		rts
-_equal_b_false	lda  #0
-		beq  _equal_b_store
-		.pend
-
-lesseq_ub	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-lesseq_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		clc
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
 reg_lesseq_uw	.proc
 		; AY <= P8ZP_SCRATCH_W2?
 		cpy  P8ZP_SCRATCH_W2+1
@@ -424,17 +67,6 @@ _true		lda  #1
 		rts
 		.pend
 
-lesseq_uw	.proc
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bcc  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
 reg_lesseq_w	.proc
 		; -- P8ZP_SCRATCH_W2 <= AY ?   (note: order different from other routines)
 		cmp  P8ZP_SCRATCH_W2
@@ -449,224 +81,6 @@ reg_lesseq_w	.proc
 		rts
 		.pend
 
-lesseq_w	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI+2,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greater_ub	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		beq  equal_b._equal_b_false
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greater_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		clc
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greater_uw	.proc
-		lda  P8ESTACK_HI+1,x
-		cmp  P8ESTACK_HI+2,x
-		bcc  equal_b._equal_b_true
-		bne  equal_b._equal_b_false
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		bcc  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
-		.pend
-
-greater_w	.proc
-		lda  P8ESTACK_LO+1,x
-		cmp  P8ESTACK_LO+2,x
-		lda  P8ESTACK_HI+1,x
-		sbc  P8ESTACK_HI+2,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_true
-		bpl  equal_b._equal_b_false
-		.pend
-
-greatereq_ub	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greatereq_b	.proc
-	; see http://www.6502.org/tutorials/compare_beyond.html
-		lda  P8ESTACK_LO+2,x
-		sec
-		sbc  P8ESTACK_LO+1,x
-		bvc  +
-		eor  #$80
-+		bpl  equal_b._equal_b_true
-		bmi  equal_b._equal_b_false
-		.pend
-
-greatereq_uw	.proc
-		lda  P8ESTACK_HI+2,x
-		cmp  P8ESTACK_HI+1,x
-		bcc  equal_b._equal_b_false
-		bne  equal_b._equal_b_true
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		bcs  equal_b._equal_b_true
-		bcc  equal_b._equal_b_false
-		.pend
-
-greatereq_w	.proc
-		lda  P8ESTACK_LO+2,x
-		cmp  P8ESTACK_LO+1,x
-		lda  P8ESTACK_HI+2,x
-		sbc  P8ESTACK_HI+1,x
-		bvc  +
-		eor  #$80
-+		bmi  equal_b._equal_b_false
-		bpl  equal_b._equal_b_true
-		.pend
-
-
-shiftleft_b	.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  +
-		rts
-+		lda  P8ESTACK_LO+1,x
--		asl  a
-		dey
-		bne  -
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-shiftright_b	.proc
-		inx
-		ldy  P8ESTACK_LO,x
-		bne  +
-		rts
-+		lda  P8ESTACK_LO+1,x
--		lsr  a
-		dey
-		bne  -
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-
-equalzero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  _true
-		bne  _false
-_true		lda  #1
-		sta  P8ESTACK_LO+1,x
-		rts
-_false		lda  #0
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-equalzero_w	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-notequalzero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-notequalzero_w	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-lesszero_b	.proc
-		lda  P8ESTACK_LO+1,x
-		bmi  equalzero_b._true
-		jmp  equalzero_b._false
-		.pend
-
-lesszero_w	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._true
-		jmp  equalzero_b._false
-		.pend
-
-greaterzero_ub	.proc
-		lda  P8ESTACK_LO+1,x
-		bne  equalzero_b._true
-		beq  equalzero_b._false
-		.pend
-
-greaterzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bpl  equalzero_b._true
-		bmi  equalzero_b._false
-		.pend
-
-greaterzero_uw	.proc
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		bne  equalzero_b._true
-		beq  equalzero_b._false
-		.pend
-
-greaterzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._false
-		ora  P8ESTACK_LO+1,x
-		beq  equalzero_b._false
-		bne  equalzero_b._true
-		.pend
-
-lessequalzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-		bmi  equalzero_b._true
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-lessequalzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._true
-		ora  P8ESTACK_LO+1,x
-		beq  equalzero_b._true
-		bne  equalzero_b._false
-		.pend
-
-greaterequalzero_sb	.proc
-		lda  P8ESTACK_LO+1,x
-	    	bpl  equalzero_b._true
-	    	bmi  equalzero_b._false
-		.pend
-
-greaterequalzero_sw	.proc
-		lda  P8ESTACK_HI+1,x
-	    	bpl  equalzero_b._true
-	    	bmi  equalzero_b._false
-		.pend
 
 memcopy16_up	.proc
 	; -- copy memory UP from (P8ZP_SCRATCH_W1) to (P8ZP_SCRATCH_W2) of length X/Y (16-bit, X=lo, Y=hi)
@@ -996,21 +410,6 @@ _arg_s1		.word  0
 _arg_s2		.word  0
 		.pend
 
-strcmp_stack	.proc
-		; -- compare strings, both on stack.
-		;    Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		jmp  strcmp_mem
-		.pend
-
-
 strcmp_mem	.proc
 		; --   compares strings in s1 (AY) and s2 (P8ZP_SCRATCH_W2).
 		;      Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
@@ -1041,16 +440,6 @@ _return_minusone
 		.pend
 
 
-sign_extend_stack_byte	.proc
-	; -- sign extend the (signed) byte on the stack to full 16 bits
-		lda  P8ESTACK_LO+1,x
-		ora  #$7f
-		bmi  +
-		lda  #0
-+		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
 strlen          .proc
         ; -- returns the number of bytes in the string in AY, in Y.
 		sta  P8ZP_SCRATCH_W1

compiler/res/prog8lib/string.p8

@@ -225,7 +225,7 @@ _done       rts
         }}
     }
 
-    asmsub lowerchar(ubyte char @A) -> ubyte @A {
+    asmsub lowerchar(ubyte character @A) -> ubyte @A {
         %asm {{
             and  #$7f
             cmp  #97
@@ -237,7 +237,7 @@ _done       rts
         }}
     }
 
-    asmsub upperchar(ubyte char @A) -> ubyte @A {
+    asmsub upperchar(ubyte character @A) -> ubyte @A {
         %asm {{
             cmp  #65
             bcc  +
@@ -280,11 +280,10 @@ _done       rts
 ;
 ; see http://6502.org/source/strings/patmatch.htm
 
-str = P8ZP_SCRATCH_W1
+strptr = P8ZP_SCRATCH_W1
 
-	stx  P8ZP_SCRATCH_REG
-	sta  str
-	sty  str+1
+	sta  strptr
+	sty  strptr+1
 	lda  cx16.r0
 	sta  modify_pattern1+1
 	sta  modify_pattern2+1
@@ -294,7 +293,6 @@ str = P8ZP_SCRATCH_W1
 	jsr  _match
 	lda  #0
 	rol  a
-	ldx  P8ZP_SCRATCH_REG
 	rts
 
 
@@ -308,9 +306,9 @@ next    lda $ffff,x   ; look at next pattern character    MODIFIED
 	iny             ; no, let's look at the string
 	cmp #'?'     ; is the pattern caracter a ques?
 	bne reg         ; no, it's a regular character
-	lda (str),y     ; yes, so it will match anything
+	lda (strptr),y     ; yes, so it will match anything
 	beq fail        ;  except the end of string
-reg     cmp (str),y     ; are both characters the same?
+reg     cmp (strptr),y     ; are both characters the same?
 	bne fail        ; no, so no match
 	inx             ; yes, keep checking
 	cmp #0          ; are we at end of string?
@@ -332,7 +330,7 @@ stloop  txa             ; we first try to match with * = ""
 	tax
 	bcs found       ; we found a match, return with c=1
 	iny             ; no match yet, try to grow * string
-	lda (str),y     ; are we at the end of string?
+	lda (strptr),y     ; are we at the end of string?
 	bne stloop      ; not yet, add a character
 fail    clc             ; yes, no match found, return with c=0
 	rts

compiler/res/prog8lib/test_stack.p8

@@ -1,4 +1,4 @@
-; utility debug code to print the X (evalstack) and SP (cpu stack) registers.
+; utility debug code to print the SP (cpu stack pointer) register.
 
 %import textio
 
@@ -7,7 +7,6 @@ test_stack {
 
     asmsub test() {
         %asm {{
-	stx  _saveX
 	lda  #13
 	jsr  txt.chrout
 	lda  #'-'
@@ -17,14 +16,6 @@ test_stack {
 	bne  -
 	lda  #13
 	jsr  txt.chrout
-	lda  #'x'
-	jsr  txt.chrout
-	lda  #'='
-	jsr  txt.chrout
-	lda  _saveX
-	jsr  txt.print_ub
-	lda  #' '
-	jsr  txt.chrout
 	lda  #'s'
 	jsr  txt.chrout
 	lda  #'p'
@@ -43,9 +34,7 @@ test_stack {
 	bne  -
 	lda  #13
 	jsr  txt.chrout
-	ldx  _saveX
 	rts
-_saveX	.byte 0
         }}
     }
 }

compiler/res/prog8lib/virtual/floats.p8

@@ -16,6 +16,15 @@ sub print_f(float value) {
     }}
 }
 
+sub parse_f(str value) -> float {
+    ; -- parse a string value of a number to float
+    %ir {{
+        loadm.w  r65535,floats.parse_f.value
+        syscall 45 (r65535.w): fr0.f
+        returnr.f fr0
+    }}
+}
+
 sub pow(float value, float power) -> float {
     %ir {{
         loadm.f fr0,floats.pow.value

compiler/src/prog8/CompilerMain.kt

@@ -3,7 +3,6 @@ package prog8
 import kotlinx.cli.*
 import prog8.ast.base.AstException
 import prog8.code.core.CbmPrgLauncherType
-import prog8.code.core.toHex
 import prog8.code.target.*
 import prog8.code.target.virtual.VirtualMachineDefinition
 import prog8.compiler.CompilationResult
@@ -39,22 +38,21 @@ private fun compileMain(args: Array<String>): Boolean {
     val cli = ArgParser("prog8compiler", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
     val asmListfile by cli.option(ArgType.Boolean, fullName = "asmlist", description = "make the assembler produce a listing file as well")
     val symbolDefs by cli.option(ArgType.String, fullName = "D", description = "define assembly symbol(s) with -D SYMBOL=VALUE").multiple()
-    val evalStackAddrString by cli.option(ArgType.String, fullName = "esa", description = "override the eval-stack base address (must be page aligned)")
     val startEmulator1 by cli.option(ArgType.Boolean, fullName = "emu", description = "auto-start emulator after successful compilation")
     val startEmulator2 by cli.option(ArgType.Boolean, fullName = "emu2", description = "auto-start alternative emulator after successful compilation")
     val experimentalCodegen by cli.option(ArgType.Boolean, fullName = "expericodegen", description = "use experimental/alternative codegen")
     val dontWriteAssembly by cli.option(ArgType.Boolean, fullName = "noasm", description="don't create assembly code")
     val dontOptimize by cli.option(ArgType.Boolean, fullName = "noopt", description = "don't perform any optimizations")
     val outputDir by cli.option(ArgType.String, fullName = "out", description = "directory for output files instead of current directory").default(".")
-    val optimizeFloatExpressions by cli.option(ArgType.Boolean, fullName = "optfloatx", description = "optimize float expressions (warning: can increase program size)")
     val quietAssembler by cli.option(ArgType.Boolean, fullName = "quietasm", description = "don't print assembler output results")
-    val slowCodegenWarnings by cli.option(ArgType.Boolean, fullName = "slowwarn", description="show debug warnings about slow/problematic assembly code generation")
+    val warnSymbolShadowing by cli.option(ArgType.Boolean, fullName = "warnshadow", description="show assembler warnings about symbol shadowing")
     val sourceDirs by cli.option(ArgType.String, fullName="srcdirs", description = "list of extra paths, separated with ${File.pathSeparator}, to search in for imported modules").multiple().delimiter(File.pathSeparator)
-    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.NAME}', '${C128Target.NAME}', '${Cx16Target.NAME}', '${AtariTarget.NAME}', '${VMTarget.NAME}') (required)")
+    val includeSourcelines by cli.option(ArgType.Boolean, fullName = "sourcelines", description = "include original Prog8 source lines in generated asm code")
+    val splitWordArrays by cli.option(ArgType.Boolean, fullName = "splitarrays", description = "treat all word arrays as tagged with @split to make them lsb/msb split in memory")
+    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.NAME}', '${C128Target.NAME}', '${Cx16Target.NAME}', '${AtariTarget.NAME}', '${PETTarget.NAME}', '${VMTarget.NAME}') (required)")
     val startVm by cli.option(ArgType.Boolean, fullName = "vm", description = "load and run a .p8ir IR source file in the VM")
     val watchMode by cli.option(ArgType.Boolean, fullName = "watch", description = "continuous compilation mode (watch for file changes)")
-    val varsHighBank by cli.option(ArgType.Int, fullName = "varshigh", description = "put uninitialized variables in high memory area instead of at the end of the program. On the cx16 target the value specifies the HiRAM bank (0=keep active), on other systems it is ignored.")
-    val splitWordArrays by cli.option(ArgType.Boolean, fullName = "splitarrays", description = "treat all word arrays as tagged with @split to make them lsb/msb split in memory")
+    val varsHighBank by cli.option(ArgType.Int, fullName = "varshigh", description = "put uninitialized variables in high memory area instead of at the end of the program. On the cx16 target the value specifies the HiRAM bank to use, on other systems this value is ignored.")
     val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
     try {
@@ -86,7 +84,7 @@ private fun compileMain(args: Array<String>): Boolean {
             return false
         }
 
-        if (compilationTarget !in setOf(C64Target.NAME, C128Target.NAME, Cx16Target.NAME, AtariTarget.NAME, VMTarget.NAME)) {
+        if (compilationTarget !in setOf(C64Target.NAME, C128Target.NAME, Cx16Target.NAME, AtariTarget.NAME, PETTarget.NAME, VMTarget.NAME)) {
             System.err.println("Invalid compilation target: $compilationTarget")
             return false
         }
@@ -101,25 +99,6 @@ private fun compileMain(args: Array<String>): Boolean {
         return runVm(moduleFiles.first())
     }
 
-    var evalStackAddr: UInt? = null
-    if(evalStackAddrString!=null) {
-        try {
-            evalStackAddr = if (evalStackAddrString!!.startsWith("0x"))
-                evalStackAddrString!!.substring(2).toUInt(16)
-            else if (evalStackAddrString!!.startsWith("$"))
-                evalStackAddrString!!.substring(1).toUInt(16)
-            else
-                evalStackAddrString!!.toUInt()
-        } catch(nx: NumberFormatException) {
-            System.err.println("invalid address for evalstack: $evalStackAddrString")
-            return false
-        }
-        if(evalStackAddr !in 256u..65536u-512u || (evalStackAddr and 255u != 0u)) {
-            System.err.println("invalid address for evalstack: ${evalStackAddr.toHex()}")
-            return false
-        }
-    }
-
     val processedSymbols = processSymbolDefs(symbolDefs) ?: return false
 
     if(watchMode==true) {
@@ -134,15 +113,14 @@ private fun compileMain(args: Array<String>): Boolean {
                 val compilerArgs = CompilerArguments(
                     filepath,
                     dontOptimize != true,
-                    optimizeFloatExpressions == true,
                     dontWriteAssembly != true,
-                    slowCodegenWarnings == true,
+                    warnSymbolShadowing == true,
                     quietAssembler == true,
                     asmListfile == true,
+                    includeSourcelines == true,
                     experimentalCodegen == true,
                     varsHighBank,
                     compilationTarget!!,
-                    evalStackAddr,
                     splitWordArrays == true,
                     processedSymbols,
                     srcdirs,
@@ -203,15 +181,14 @@ private fun compileMain(args: Array<String>): Boolean {
                 val compilerArgs = CompilerArguments(
                     filepath,
                     dontOptimize != true,
-                    optimizeFloatExpressions == true,
                     dontWriteAssembly != true,
-                    slowCodegenWarnings == true,
+                    warnSymbolShadowing == true,
                     quietAssembler == true,
                     asmListfile == true,
+                    includeSourcelines == true,
                     experimentalCodegen == true,
                     varsHighBank,
                     compilationTarget!!,
-                    evalStackAddr,
                     splitWordArrays == true,
                     processedSymbols,
                     srcdirs,

compiler/src/prog8/buildversion/BuildVersion.kt

@@ -5,11 +5,11 @@ package prog8.buildversion
  */
 const val MAVEN_GROUP = "prog8"
 const val MAVEN_NAME = "compiler"
-const val VERSION = "9.2-SNAPSHOT"
-const val GIT_REVISION = 3964
-const val GIT_SHA = "aaa30e4a583fa7c8da61998cf7cbb2a60b52afb0"
-const val GIT_DATE = "2023-07-16T21:16:18Z"
+const val VERSION = "9.3-SNAPSHOT"
+const val GIT_REVISION = 4012
+const val GIT_SHA = "9167ba499de99696aa7c6887d4867eae70eb5caf"
+const val GIT_DATE = "2023-07-30T15:49:35Z"
 const val GIT_BRANCH = "master"
-const val BUILD_DATE = "2023-07-16T21:16:23Z"
-const val BUILD_UNIX_TIME = 1689542183583L
+const val BUILD_DATE = "2023-07-30T16:41:27Z"
+const val BUILD_UNIX_TIME = 1690735287514L
 const val DIRTY = 1

compiler/src/prog8/compiler/Compiler.kt

@@ -29,15 +29,14 @@ class CompilationResult(val compilerAst: Program,   // deprecated, use codegenAs
 
 class CompilerArguments(val filepath: Path,
                         val optimize: Boolean,
-                        val optimizeFloatExpressions: Boolean,
                         val writeAssembly: Boolean,
-                        val slowCodegenWarnings: Boolean,
+                        val warnSymbolShadowing: Boolean,
                         val quietAssembler: Boolean,
                         val asmListfile: Boolean,
+                        val includeSourcelines: Boolean,
                         val experimentalCodegen: Boolean,
                         val varsHighBank: Int?,
                         val compilationTarget: String,
-                        val evalStackBaseAddress: UInt?,
                         val splitWordArrays: Boolean,
                         val symbolDefs: Map<String, String>,
                         val sourceDirs: List<String> = emptyList(),
@@ -49,13 +48,12 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
     lateinit var program: Program
     lateinit var importedFiles: List<Path>
 
-    val optimizeFloatExpr = if(args.optimize) args.optimizeFloatExpressions else false
-
     val compTarget =
         when(args.compilationTarget) {
             C64Target.NAME -> C64Target()
             C128Target.NAME -> C128Target()
             Cx16Target.NAME -> Cx16Target()
+            PETTarget.NAME -> PETTarget()
             AtariTarget.NAME -> AtariTarget()
             VMTarget.NAME -> VMTarget()
             else -> throw IllegalArgumentException("invalid compilation target")
@@ -70,14 +68,13 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
             compilationOptions = options
 
             with(compilationOptions) {
-                slowCodegenWarnings = args.slowCodegenWarnings
+                warnSymbolShadowing = args.warnSymbolShadowing
                 optimize = args.optimize
-                optimizeFloatExpressions = optimizeFloatExpr
                 asmQuiet = args.quietAssembler
                 asmListfile = args.asmListfile
+                includeSourcelines = args.includeSourcelines
                 experimentalCodegen = args.experimentalCodegen
                 varsHighBank = args.varsHighBank
-                evalStackBaseAddress = args.evalStackBaseAddress
                 splitWordArrays = args.splitWordArrays
                 outputDir = args.outputDir.normalize()
                 symbolDefs = args.symbolDefs
@@ -85,10 +82,6 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
             program = programresult
             importedFiles = imported
 
-            if(compilationOptions.evalStackBaseAddress!=null) {
-                compTarget.machine.overrideEvalStack(compilationOptions.evalStackBaseAddress!!)
-            }
-
             processAst(program, args.errors, compilationOptions)
             if (compilationOptions.optimize) {
 //                println("*********** COMPILER AST RIGHT BEFORE OPTIMIZING *************")
@@ -116,7 +109,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
                 program.processAstBeforeAsmGeneration(compilationOptions, args.errors)
                 args.errors.report()
 
-                val intermediateAst = IntermediateAstMaker(program, compilationOptions).transform()
+                val intermediateAst = IntermediateAstMaker(program).transform()
 //                println("*********** COMPILER AST RIGHT BEFORE ASM GENERATION *************")
 //                printProgram(program)
 //                println("*********** AST RIGHT BEFORE ASM GENERATION *************")
@@ -346,7 +339,7 @@ private fun processAst(program: Program, errors: IErrorReporter, compilerOptions
     errors.report()
     program.desugaring(errors)
     errors.report()
-    program.reorderStatements(errors, compilerOptions)
+    program.reorderStatements(errors)
     errors.report()
     program.changeNotExpressionAndIfComparisonExpr(errors, compilerOptions.compTarget)
     errors.report()
@@ -367,12 +360,11 @@ private fun optimizeAst(program: Program, compilerOptions: CompilationOptions, e
     while (true) {
         // keep optimizing expressions and statements until no more steps remain
         val optsDone1 = program.simplifyExpressions(errors, compTarget)
-        val optsDone2 = program.splitBinaryExpressions(compilerOptions)
-        val optsDone3 = program.optimizeStatements(errors, functions, compilerOptions)
-        val optsDone4 = program.inlineSubroutines(compilerOptions)
+        val optsDone2 = program.optimizeStatements(errors, functions, compilerOptions)
+        val optsDone3 = program.inlineSubroutines(compilerOptions)
         program.constantFold(errors, compTarget) // because simplified statements and expressions can result in more constants that can be folded away
         errors.report()
-        if (optsDone1 + optsDone2 + optsDone3 + optsDone4 == 0)
+        if (optsDone1 + optsDone2 + optsDone3 == 0)
             break
     }
     val remover2 = UnusedCodeRemover(program, errors, compTarget)

compiler/src/prog8/compiler/ModuleImporter.kt

@@ -117,7 +117,7 @@ class ModuleImporter(private val program: Program,
                     importedModule.statements.remove(block)
                 } else {
                     val merges = block.statements.filter { it is Directive && it.directive=="%option" && it.args.any { a->a.name=="merge" } }
-                    block.statements.removeAll(merges)
+                    block.statements.removeAll(merges.toSet())
                 }
             }
         }
@@ -129,7 +129,7 @@ class ModuleImporter(private val program: Program,
         // Most global directives don't apply for imported modules, so remove them
         val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
         var directives = importedModule.statements.filterIsInstance<Directive>()
-        importedModule.statements.removeAll(directives)
+        importedModule.statements.removeAll(directives.toSet())
         directives = directives.filter{ it.directive !in moduleLevelDirectives }
         importedModule.statements.addAll(0, directives)
     }

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

@@ -116,7 +116,7 @@ internal class AstChecker(private val program: Program,
                             errors.err("type $valueDt of return value doesn't match subroutine's return type ${expectedReturnValues[0]}",returnStmt.value!!.position)
                         }
                     } else if(valueDt.isIterable && expectedReturnValues[0]==DataType.UWORD) {
-                        // you can return a string or array when a uword (pointer) is returned
+                        // you can return a string or array when an uword (pointer) is returned
                     }
                     else {
                         errors.err("type $valueDt of return value doesn't match subroutine's return type ${expectedReturnValues[0]}",returnStmt.value!!.position)
@@ -220,7 +220,7 @@ internal class AstChecker(private val program: Program,
     override fun visit(jump: Jump) {
         val ident = jump.identifier
         if(ident!=null) {
-            val targetStatement = checkFunctionOrLabelExists(ident, jump)
+            val targetStatement = ident.checkFunctionOrLabelExists(program, jump, errors)
             if(targetStatement!=null) {
                 if(targetStatement is BuiltinFunctionPlaceholder)
                     errors.err("can't jump to a builtin function", jump.position)
@@ -1068,7 +1068,7 @@ internal class AstChecker(private val program: Program,
         val stmtOfExpression = findParentNode<Statement>(functionCallExpr)
                 ?: throw FatalAstException("cannot determine statement scope of function call expression at ${functionCallExpr.position}")
 
-        val targetStatement = checkFunctionOrLabelExists(functionCallExpr.target, stmtOfExpression)
+        val targetStatement = functionCallExpr.target.checkFunctionOrLabelExists(program, stmtOfExpression, errors)
         if(targetStatement!=null)
             checkFunctionCall(targetStatement, functionCallExpr.args, functionCallExpr.position)
 
@@ -1120,7 +1120,7 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(functionCallStatement: FunctionCallStatement) {
-        val targetStatement = checkFunctionOrLabelExists(functionCallStatement.target, functionCallStatement)
+        val targetStatement = functionCallStatement.target.checkFunctionOrLabelExists(program, functionCallStatement, errors)
         if(targetStatement!=null) {
             checkFunctionCall(targetStatement, functionCallStatement.args, functionCallStatement.position)
             checkUnusedReturnValues(functionCallStatement, targetStatement, errors)
@@ -1416,23 +1416,9 @@ internal class AstChecker(private val program: Program,
         super.visit(memwrite)
     }
 
-    private fun checkFunctionOrLabelExists(target: IdentifierReference, statement: Statement): Statement? {
-        when (val targetStatement = target.targetStatement(program)) {
-            is Label, is Subroutine, is BuiltinFunctionPlaceholder -> return targetStatement
-            is VarDecl -> {
-                if(statement is Jump) {
-                    if (targetStatement.datatype == DataType.UWORD)
-                        return targetStatement
-                    else
-                        errors.err("wrong address variable datatype, expected uword", target.position)
-                }
-                else
-                    errors.err("cannot call that: ${target.nameInSource.joinToString(".")}", target.position)
-            }
-            null -> errors.undefined(target.nameInSource, target.position)
-            else -> errors.err("cannot call that: ${target.nameInSource.joinToString(".")}", target.position)
-        }
-        return null
+    override fun visit(inlineAssembly: InlineAssembly) {
+        if(inlineAssembly.isIR && compilerOptions.compTarget.name != VMTarget.NAME)
+            errors.err("%asm containing IR code cannot be translated to 6502 assembly", inlineAssembly.position)
     }
 
     private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteral) : Boolean {

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

@@ -5,10 +5,7 @@ import prog8.ast.Program
 import prog8.ast.expressions.CharLiteral
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
-import prog8.ast.statements.Directive
-import prog8.ast.statements.InlineAssembly
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.VarDeclOrigin
+import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
@@ -27,7 +24,7 @@ internal fun Program.processAstBeforeAsmGeneration(compilerOptions: CompilationO
     boolRemover.visit(this)
     boolRemover.applyModifications()
 
-    val fixer = BeforeAsmAstChanger(this, compilerOptions, errors)
+    val fixer = BeforeAsmAstChanger(this, compilerOptions)
     fixer.visit(this)
     while (errors.noErrors() && fixer.applyModifications() > 0) {
         fixer.visit(this)
@@ -39,8 +36,8 @@ internal fun Program.processAstBeforeAsmGeneration(compilerOptions: CompilationO
     }
 }
 
-internal fun Program.reorderStatements(errors: IErrorReporter, options: CompilationOptions) {
-    val reorder = StatementReorderer(this, errors, options)
+internal fun Program.reorderStatements(errors: IErrorReporter) {
+    val reorder = StatementReorderer(this, errors)
     reorder.visit(this)
     if(errors.noErrors()) {
         reorder.applyModifications()
@@ -108,9 +105,6 @@ internal fun Program.checkIdentifiers(errors: IErrorReporter, options: Compilati
     checker2.visit(this)
 
     if(errors.noErrors()) {
-        val transforms = AstOnetimeTransforms(this, options)
-        transforms.visit(this)
-        transforms.applyModifications()
         val lit2decl = LiteralsToAutoVars(this, options.compTarget, errors)
         lit2decl.visit(this)
         if(errors.noErrors())
@@ -154,4 +148,25 @@ internal fun Subroutine.hasRtsInAsm(): Boolean {
         .asSequence()
         .filterIsInstance<InlineAssembly>()
         .any { it.hasReturnOrRts() }
+}
+
+internal fun IdentifierReference.checkFunctionOrLabelExists(program: Program, statement: Statement, errors: IErrorReporter): Statement? {
+    when (val targetStatement = this.targetStatement(program)) {
+        is Label, is Subroutine, is BuiltinFunctionPlaceholder -> return targetStatement
+        is VarDecl -> {
+            if(statement is Jump) {
+                if (targetStatement.datatype == DataType.UWORD)
+                    return targetStatement
+                else
+                    errors.err("wrong address variable datatype, expected uword", this.position)
+            }
+            else
+                errors.err("cannot call that: ${this.nameInSource.joinToString(".")}", this.position)
+        }
+        null -> {
+            errors.undefined(this.nameInSource, this.position)
+        }
+        else -> errors.err("cannot call that: ${this.nameInSource.joinToString(".")}", this.position)
+    }
+    return null
 }

compiler/src/prog8/compiler/astprocessing/AstOnetimeTransforms.kt

@@ -1,62 +0,0 @@
-package prog8.compiler.astprocessing
-
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.expressions.*
-import prog8.ast.statements.AssignTarget
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.DirectMemoryWrite
-import prog8.ast.statements.VarDecl
-import prog8.ast.walk.AstWalker
-import prog8.ast.walk.IAstModification
-import prog8.code.core.CompilationOptions
-import prog8.code.core.DataType
-import prog8.code.target.VMTarget
-
-
-internal class AstOnetimeTransforms(private val program: Program, private val options: CompilationOptions) : AstWalker() {
-
-    override fun after(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
-        if(parent !is VarDecl) {
-            if(options.compTarget.name == VMTarget.NAME)
-                return noModifications  // vm codegen deals correctly with all cases
-            // Don't replace the initializer value in a vardecl - this will be moved to a separate
-            // assignment statement soon in after(VarDecl)
-            return replacePointerVarIndexWithMemreadOrMemwrite(arrayIndexedExpression, parent)
-        }
-        return noModifications
-    }
-
-    private fun replacePointerVarIndexWithMemreadOrMemwrite(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
-        // note: The CodeDesugarer already does something similar, but that is meant ONLY to take
-        //       into account the case where the index value is a word type.
-        //       The replacement here is to fix missing cases in the 6502 codegen. (VM codegen doesn't use this workaround)
-        // TODO make the 6502 codegen better so this workaround can be removed
-        val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program)
-        if(arrayVar!=null && arrayVar.datatype == DataType.UWORD) {
-            if(parent is AssignTarget) {
-                val assignment = parent.parent as? Assignment
-                if(assignment?.value is NumericLiteral || assignment?.value is IdentifierReference) {
-                    // the codegen contains correct optimized code ONLY for a constant assignment, or direct variable assignment.
-                    return noModifications
-                }
-                // Other cases aren't covered correctly by the 6502 codegen, and there are a LOT of cases.
-                // So rewrite assignment target   pointervar[index]  into  @(pointervar+index)
-                // (the 6502 codegen covers all cases correctly for a direct memory assignment).
-                val indexer = arrayIndexedExpression.indexer
-                val add: Expression =
-                if(indexer.indexExpr.constValue(program)?.number==0.0)
-                    arrayIndexedExpression.arrayvar.copy()
-                else
-                    BinaryExpression(arrayIndexedExpression.arrayvar.copy(), "+", indexer.indexExpr, arrayIndexedExpression.position)
-                val memwrite = DirectMemoryWrite(add, arrayIndexedExpression.position)
-                val newtarget = AssignTarget(null, null, memwrite, arrayIndexedExpression.position)
-                return listOf(IAstModification.ReplaceNode(parent, newtarget, parent.parent))
-            }
-        }
-
-        return noModifications
-    }
-}
-
-

compiler/src/prog8/compiler/astprocessing/AstPreprocessor.kt

@@ -1,16 +1,17 @@
 package prog8.compiler.astprocessing
 
+import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
+import prog8.ast.base.FatalAstException
 import prog8.ast.base.SyntaxError
 import prog8.ast.expressions.*
+import prog8.ast.findParentNode
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
 import prog8.code.target.C64Target
-import prog8.code.target.Cx16Target
-import prog8.code.target.VMTarget
 
 
 class AstPreprocessor(val program: Program,
@@ -25,15 +26,10 @@ class AstPreprocessor(val program: Program,
                 relocateCx16VirtualRegisters(program, 0x0004u)
             }
         }
-        else if(options.compTarget.name !in setOf(Cx16Target.NAME, VMTarget.NAME)) {
-            relocateCx16VirtualRegisters(program, options.compTarget.machine.ESTACK_HI)
-        }
         return noModifications
     }
 
     private fun relocateCx16VirtualRegisters(program: Program, baseAddress: UInt) {
-        // reset the address of the virtual registers to be inside the evaluation stack.
-        // (we don't do this on CommanderX16 itself as the registers have a fixed location in Zeropage there)
         val cx16block = program.allBlocks.single { it.name == "cx16" }
         val memVars = cx16block.statements
             .filterIsInstance<VarDecl>()
@@ -208,4 +204,42 @@ class AstPreprocessor(val program: Program,
 
         return noModifications
     }
+
+    override fun after(bfc: BuiltinFunctionCall, parent: Node): Iterable<IAstModification> {
+        val stmtOfExpression = findParentNode<Statement>(bfc)
+            ?: throw FatalAstException("cannot determine statement scope of function call expression at ${bfc.position}")
+        checkStringParam(bfc as IFunctionCall, stmtOfExpression)
+        return noModifications
+    }
+
+    override fun after(bfcs: BuiltinFunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        checkStringParam(bfcs as IFunctionCall, bfcs)
+        return noModifications
+    }
+
+    override fun after(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
+        val stmtOfExpression = findParentNode<Statement>(functionCallExpr)
+            ?: throw FatalAstException("cannot determine statement scope of function call expression at ${functionCallExpr.position}")
+
+        checkStringParam(functionCallExpr as IFunctionCall, stmtOfExpression)
+        return noModifications
+    }
+
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        checkStringParam(functionCallStatement as IFunctionCall, functionCallStatement)
+        return noModifications
+    }
+
+    private fun checkStringParam(call: IFunctionCall, stmt: Statement) {
+        val targetStatement = call.target.checkFunctionOrLabelExists(program, stmt, errors)
+        if(targetStatement!=null) {
+            if(targetStatement is Subroutine) {
+                for(arg in call.args.zip(targetStatement.parameters)) {
+                    if(arg.first.inferType(program).isBytes && arg.second.type==DataType.STR) {
+                        errors.err("cannot use byte value for string parameter", arg.first.position)
+                    }
+                }
+            }
+        }
+    }
 }

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

@@ -9,14 +9,10 @@ import prog8.ast.getTempVar
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.ast.walk.IAstVisitor
 import prog8.code.core.*
 import prog8.code.target.VMTarget
 
-internal class BeforeAsmAstChanger(val program: Program,
-                                   private val options: CompilationOptions,
-                                   private val errors: IErrorReporter
-) : AstWalker() {
+internal class BeforeAsmAstChanger(val program: Program, private val options: CompilationOptions) : AstWalker() {
 
     override fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> {
         throw InternalCompilerException("break should have been replaced by goto $breakStmt")
@@ -56,9 +52,6 @@ internal class BeforeAsmAstChanger(val program: Program,
             && !assignment.target.isIOAddress(options.compTarget.machine)) {
             val binExpr = assignment.value as? BinaryExpression
 
-            if(binExpr!=null && binExpr.inferType(program) istype DataType.FLOAT && !options.optimizeFloatExpressions)
-                return noModifications
-
             if (binExpr != null && binExpr.operator !in ComparisonOperators) {
                 if (binExpr.left !is BinaryExpression) {
                     if (binExpr.right.referencesIdentifier(assignment.target.identifier!!.nameInSource)) {
@@ -150,7 +143,7 @@ internal class BeforeAsmAstChanger(val program: Program,
             }
         }
 
-        if (!subroutine.inline || !options.optimize) {
+        if (!subroutine.inline) {
             if (subroutine.isAsmSubroutine && subroutine.asmAddress==null && !subroutine.hasRtsInAsm()) {
                 // make sure the NOT INLINED asm subroutine actually has a rts at the end
                 // (non-asm routines get a Return statement as needed, above)
@@ -222,12 +215,6 @@ internal class BeforeAsmAstChanger(val program: Program,
     override fun after(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
 
         if(options.compTarget.name!=VMTarget.NAME) {    // don't apply this optimization/check for Vm target
-            val containingStatement = getContainingStatement(arrayIndexedExpression)
-            if(getComplexArrayIndexedExpressions(containingStatement).size > 1) {
-                errors.err("it's not possible to use more than one complex array indexing expression in a single statement; break it up via a temporary variable for instance", containingStatement.position)
-                return noModifications
-            }
-
             val index = arrayIndexedExpression.indexer.indexExpr
             if (index !is NumericLiteral && index !is IdentifierReference) {
                 // replace complex indexing expression with a temp variable to hold the computed index first
@@ -238,42 +225,6 @@ internal class BeforeAsmAstChanger(val program: Program,
         return noModifications
     }
 
-    private fun getComplexArrayIndexedExpressions(stmt: Statement): List<ArrayIndexedExpression> {
-
-        class Searcher : IAstVisitor {
-            val complexArrayIndexedExpressions = mutableListOf<ArrayIndexedExpression>()
-            override fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
-                val ix = arrayIndexedExpression.indexer.indexExpr
-                if(ix !is NumericLiteral && ix !is IdentifierReference)
-                    complexArrayIndexedExpressions.add(arrayIndexedExpression)
-            }
-
-            override fun visit(branch: ConditionalBranch) {}
-
-            override fun visit(forLoop: ForLoop) {}
-
-            override fun visit(ifElse: IfElse) {
-                ifElse.condition.accept(this)
-            }
-
-            override fun visit(untilLoop: UntilLoop) {
-                untilLoop.condition.accept(this)
-            }
-        }
-
-        val searcher = Searcher()
-        stmt.accept(searcher)
-        return searcher.complexArrayIndexedExpressions
-    }
-
-    private fun getContainingStatement(expression: Expression): Statement {
-        var node: Node = expression
-        while(node !is Statement)
-            node = node.parent
-
-        return node
-    }
-
     private fun getAutoIndexerVarFor(expr: ArrayIndexedExpression): MutableList<IAstModification> {
         val modifications = mutableListOf<IAstModification>()
         val statement = expr.containingStatement

compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt

@@ -200,6 +200,15 @@ _after:
             }
         }
 
+        if(expr.operator=="*" && expr.inferType(program).isInteger && expr.left isSameAs expr.right) {
+            // replace squaring with call to builtin function to do this in a more optimized way
+            val function = if(expr.left.inferType(program).isBytes) "prog8_lib_square_byte" else "prog8_lib_square_word"
+            val squareCall = BuiltinFunctionCall(
+                IdentifierReference(listOf(function), expr.position),
+                mutableListOf(expr.left.copy()), expr.position)
+            return listOf(IAstModification.ReplaceNode(expr, squareCall, parent))
+        }
+
         return noModifications
     }
 }

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

@@ -19,7 +19,7 @@ import kotlin.io.path.isRegularFile
 /**
  *  Convert 'old' compiler-AST into the 'new' simplified AST with baked types.
  */
-class IntermediateAstMaker(private val program: Program, private val options: CompilationOptions) {
+class IntermediateAstMaker(private val program: Program) {
     fun transform(): PtProgram {
         val ptProgram = PtProgram(
             program.name,
@@ -529,9 +529,9 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
 
 
     private fun loadAsmIncludeFile(filename: String, source: SourceCode): Result<String, NoSuchFileException> {
-        return if (filename.startsWith(SourceCode.libraryFilePrefix)) {
+        return if (filename.startsWith(SourceCode.LIBRARYFILEPREFIX)) {
             return com.github.michaelbull.result.runCatching {
-                SourceCode.Resource("/prog8lib/${filename.substring(SourceCode.libraryFilePrefix.length)}").text
+                SourceCode.Resource("/prog8lib/${filename.substring(SourceCode.LIBRARYFILEPREFIX.length)}").text
             }.mapError { NoSuchFileException(File(filename)) }
         } else {
             val sib = Path(source.origin).resolveSibling(filename)

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

@@ -7,9 +7,9 @@ import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
 
-internal class StatementReorderer(val program: Program,
-                                  val errors: IErrorReporter,
-                                  private val options: CompilationOptions
+internal class StatementReorderer(
+    val program: Program,
+    val errors: IErrorReporter
 ) : AstWalker() {
     // Reorders the statements in a way the compiler needs.
     // - 'main' block must be the very first statement UNLESS it has an address set.
@@ -109,7 +109,7 @@ internal class StatementReorderer(val program: Program,
 
     private fun directivesToTheTop(statements: MutableList<Statement>) {
         val directives = statements.filterIsInstance<Directive>().filter {it.directive in directivesToMove}
-        statements.removeAll(directives)
+        statements.removeAll(directives.toSet())
         statements.addAll(0, directives)
     }
 

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

@@ -262,15 +262,5 @@ internal class VariousCleanups(val program: Program, val errors: IErrorReporter,
         }
         return noModifications
     }
-
-    override fun after(whenStmt: When, parent: Node): Iterable<IAstModification> {
-        val removals = mutableListOf<Int>()
-        whenStmt.choices.withIndex().forEach { (index, choice) ->
-            if(choice.statements.isEmpty())
-                removals.add(index)
-        }
-        removals.reversed().forEach { whenStmt.choices.removeAt(it) }
-        return noModifications
-    }
 }
 

compiler/test/TestAstChecks.kt

@@ -11,7 +11,7 @@ import prog8tests.helpers.compileText
 
 class TestAstChecks: FunSpec({
 
-    test("conditional expression w/float works even without tempvar to split it") {
+    test("conditional expression w/float works") {
         val text = """
             %import floats
             main {

compiler/test/TestCompilerOnExamples.kt

@@ -26,15 +26,14 @@ private fun compileTheThing(filepath: Path, optimize: Boolean, target: ICompilat
     val args = CompilerArguments(
         filepath,
         optimize,
-        optimizeFloatExpressions = true,
         writeAssembly = true,
-        slowCodegenWarnings = false,
+        warnSymbolShadowing = false,
         quietAssembler = true,
         asmListfile = false,
+        includeSourcelines = false,
         experimentalCodegen = false,
         varsHighBank = null,
         compilationTarget = target.name,
-        evalStackBaseAddress = null,
         splitWordArrays = false,
         symbolDefs = emptyMap(),
         outputDir = outputDir

compiler/test/TestCompilerOnRanges.kt

@@ -264,7 +264,15 @@ class TestCompilerOnRanges: FunSpec({
             NumericLiteral.optimalInteger(2, Position.DUMMY),
             Position.DUMMY)
         expr.size() shouldBe 6
-        expr.toConstantIntegerRange()
+        expr.toConstantIntegerRange() shouldBe (10..20 step 2)
+
+        val expr2 = RangeExpression(
+            NumericLiteral.optimalInteger(20, Position.DUMMY),
+            NumericLiteral.optimalInteger(10, Position.DUMMY),
+            NumericLiteral.optimalInteger(-3, Position.DUMMY),
+            Position.DUMMY)
+        expr2.size() shouldBe 4
+        expr2.toConstantIntegerRange() shouldBe (20 downTo 10 step 3)
     }
 
     test("range with negative step should be constvalue") {

compiler/test/TestCompilerOptionLibdirs.kt

@@ -43,15 +43,14 @@ class TestCompilerOptionSourcedirs: FunSpec({
         val args = CompilerArguments(
             filepath = filePath,
             optimize = false,
-            optimizeFloatExpressions = false,
             writeAssembly = true,
-            slowCodegenWarnings = false,
+            warnSymbolShadowing = false,
             quietAssembler = true,
             asmListfile = false,
+            includeSourcelines = false,
             experimentalCodegen = false,
             varsHighBank = null,
             compilationTarget = Cx16Target.NAME,
-            evalStackBaseAddress = null,
             splitWordArrays = false,
             symbolDefs = emptyMap(),
             sourceDirs,

compiler/test/TestOptimization.kt

@@ -120,36 +120,31 @@ class TestOptimization: FunSpec({
 //        load_location = 12345
 //        word llw
 //        llw = 12345
-//        cx16.r0 = load_location
-//        cx16.r0 += 10000
-//        cx16.r2 = load_location
-//        cx16.r2 += 10000
-//        cx16.r4 = load_location
-//        cx16.r4 += 22
-//        cx16.r5s = llw
-//        cx16.r5s -= 1899
-//        cx16.r7s = llw
-//        cx16.r7s += 99
+//        cx16.r0 = load_location + 10000
+//        cx16.r2 = load_location + 10000
+//        cx16.r4 = load_location + 22
+//        cx16.r5s = llw - 1899
+//        cx16.r7s = llw + 99
         val stmts = result.compilerAst.entrypoint.statements
-        stmts.size shouldBe 14
+        stmts.size shouldBe 9
 
-        val addR0value = (stmts[5] as Assignment).value
+        val addR0value = (stmts[4] as Assignment).value
         val binexpr0 = addR0value as BinaryExpression
         binexpr0.operator shouldBe "+"
         binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY)
-        val addR2value = (stmts[7] as Assignment).value
+        val addR2value = (stmts[5] as Assignment).value
         val binexpr2 = addR2value as BinaryExpression
         binexpr2.operator shouldBe "+"
         binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 10000.0, Position.DUMMY)
-        val addR4value = (stmts[9] as Assignment).value
+        val addR4value = (stmts[6] as Assignment).value
         val binexpr4 = addR4value as BinaryExpression
         binexpr4.operator shouldBe "+"
         binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 22.0, Position.DUMMY)
-        val subR5value = (stmts[11] as Assignment).value
+        val subR5value = (stmts[7] as Assignment).value
         val binexpr5 = subR5value as BinaryExpression
         binexpr5.operator shouldBe "-"
         binexpr5.right shouldBe NumericLiteral(DataType.UWORD, 1899.0, Position.DUMMY)
-        val subR7value = (stmts[13] as Assignment).value
+        val subR7value = (stmts[8] as Assignment).value
         val binexpr7 = subR7value as BinaryExpression
         binexpr7.operator shouldBe "+"
         binexpr7.right shouldBe NumericLiteral(DataType.UWORD, 99.0, Position.DUMMY)
@@ -171,44 +166,34 @@ class TestOptimization: FunSpec({
         // expected:
 //        word llw
 //        llw = 300
-//        cx16.r0s = llw
-//        cx16.r0s *= 180
-//        cx16.r1s = llw
-//        cx16.r1s *= 180
-//        cx16.r2s = llw
-//        cx16.r2s /= 90
-//        cx16.r3s = llw
-//        cx16.r3s *= 5
-//        cx16.r4s = llw
-//        cx16.r4s *= 90
-//        cx16.r4s /= 5
+//        cx16.r0s = llw * 180
+//        cx16.r1s = llw * 180
+//        cx16.r2s = llw / 90
+//        cx16.r3s = llw * 5
+//        cx16.r4s = llw * 90 / 5
         val stmts = result.compilerAst.entrypoint.statements
-        stmts.size shouldBe 13
+        stmts.size shouldBe 7
 
-        val mulR0Value = (stmts[3] as Assignment).value
+        val mulR0Value = (stmts[2] as Assignment).value
         val binexpr0 = mulR0Value as BinaryExpression
         binexpr0.operator shouldBe "*"
         binexpr0.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY)
-        val mulR1Value = (stmts[5] as Assignment).value
+        val mulR1Value = (stmts[3] as Assignment).value
         val binexpr1 = mulR1Value as BinaryExpression
         binexpr1.operator shouldBe "*"
         binexpr1.right shouldBe NumericLiteral(DataType.UWORD, 180.0, Position.DUMMY)
-        val divR2Value = (stmts[7] as Assignment).value
+        val divR2Value = (stmts[4] as Assignment).value
         val binexpr2 = divR2Value as BinaryExpression
         binexpr2.operator shouldBe "/"
         binexpr2.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY)
-        val mulR3Value = (stmts[9] as Assignment).value
+        val mulR3Value = (stmts[5] as Assignment).value
         val binexpr3 = mulR3Value as BinaryExpression
         binexpr3.operator shouldBe "*"
         binexpr3.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY)
-        val mulR4Value = (stmts[11] as Assignment).value
+        val mulR4Value = (stmts[6] as Assignment).value
         val binexpr4 = mulR4Value as BinaryExpression
-        binexpr4.operator shouldBe "*"
-        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 90.0, Position.DUMMY)
-        val divR4Value = (stmts[12] as Assignment).value
-        val binexpr4b = divR4Value as BinaryExpression
-        binexpr4b.operator shouldBe "/"
-        binexpr4b.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY)
+        binexpr4.operator shouldBe "/"
+        binexpr4.right shouldBe NumericLiteral(DataType.UWORD, 5.0, Position.DUMMY)
     }
 
     test("constantfolded and silently typecasted for initializervalues") {
@@ -377,14 +362,12 @@ class TestOptimization: FunSpec({
         uword z4
         z4 = 0
         ubyte z5
-        z5 = z1
-        z5 += 5
+        z5 = z1 + 5
         ubyte z6
-        z6 = z1
-        z6 -= 5
+        z6 = z1 - 5
         */
         val statements = result.compilerAst.entrypoint.statements
-        statements.size shouldBe 14
+        statements.size shouldBe 12
         val z1decl = statements[0] as VarDecl
         val z1init = statements[1] as Assignment
         val z2decl = statements[2] as VarDecl
@@ -395,10 +378,8 @@ class TestOptimization: FunSpec({
         val z4init = statements[7] as Assignment
         val z5decl = statements[8] as VarDecl
         val z5init = statements[9] as Assignment
-        val z5plus = statements[10] as Assignment
-        val z6decl = statements[11] as VarDecl
-        val z6init = statements[12] as Assignment
-        val z6plus = statements[13] as Assignment
+        val z6decl = statements[10] as VarDecl
+        val z6init = statements[11] as Assignment
 
         z1decl.name shouldBe "z1"
         z1init.value shouldBe NumericLiteral(DataType.UBYTE, 10.0, Position.DUMMY)
@@ -409,15 +390,11 @@ class TestOptimization: FunSpec({
         z4decl.name shouldBe "z4"
         z4init.value shouldBe NumericLiteral(DataType.UBYTE, 0.0, Position.DUMMY)
         z5decl.name shouldBe "z5"
-        (z5init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1")
-        z5plus.isAugmentable shouldBe true
-        (z5plus.value as BinaryExpression).operator shouldBe "+"
-        (z5plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
+        (z5init.value as BinaryExpression).operator shouldBe "+"
+        (z5init.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
         z6decl.name shouldBe "z6"
-        (z6init.value as? IdentifierReference)?.nameInSource shouldBe listOf("z1")
-        z6plus.isAugmentable shouldBe true
-        (z6plus.value as BinaryExpression).operator shouldBe "-"
-        (z6plus.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
+        (z6init.value as BinaryExpression).operator shouldBe "-"
+        (z6init.value as BinaryExpression).right shouldBe NumericLiteral(DataType.UBYTE, 5.0, Position.DUMMY)
     }
 
     test("force_output option should work with optimizing memwrite assignment") {
@@ -435,7 +412,7 @@ class TestOptimization: FunSpec({
 
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
         val stmts = result.compilerAst.entrypoint.statements
-        stmts.size shouldBe 6
+        stmts.size shouldBe 5
         val assign=stmts.last() as Assignment
         (assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
     }
@@ -452,7 +429,7 @@ class TestOptimization: FunSpec({
         """
         val result = compileText(C64Target(), optimize=true, src, writeAssembly=false)!!
         val stmts = result.compilerAst.entrypoint.statements
-        stmts.size shouldBe 6
+        stmts.size shouldBe 5
         val assign=stmts.last() as Assignment
         (assign.target.memoryAddress?.addressExpression as IdentifierReference).nameInSource shouldBe listOf("aa")
     }
@@ -548,9 +525,9 @@ class TestOptimization: FunSpec({
         xx += 6
          */
         val stmts = result.compilerAst.entrypoint.statements
-        stmts.size shouldBe 8
+        stmts.size shouldBe 7
         stmts.filterIsInstance<VarDecl>().size shouldBe 3
-        stmts.filterIsInstance<Assignment>().size shouldBe 5
+        stmts.filterIsInstance<Assignment>().size shouldBe 4
     }
 
     test("only substitue assignments with 0 after a =0 initializer if it is the same variable") {

compiler/test/TestTypecasts.kt

@@ -95,19 +95,16 @@ main {
         ubyte ub3
         ub3 = 1
         ubyte @shared bvalue
-        bvalue = ub1
-        bvalue ^= ub2
-        bvalue ^= ub3
-        bvalue ^= 1
+        bvalue = ub1 ^ ub2 ^ ub3 ^ true
         bvalue = (((ub1^ub2)^ub3)^(ftrue(99)!=0))
         bvalue = ((ub1&ub2)&(ftrue(99)!=0))
         return
          */
-        stmts.size shouldBe 14
-        val assignValue1 = (stmts[7] as Assignment).value as IdentifierReference
-        val assignValue2 = (stmts[11] as Assignment).value as BinaryExpression
-        val assignValue3 = (stmts[12] as Assignment).value as BinaryExpression
-        assignValue1.nameInSource shouldBe listOf("ub1")
+        stmts.size shouldBe 11
+        val assignValue1 = (stmts[7] as Assignment).value as BinaryExpression
+        val assignValue2 = (stmts[8] as Assignment).value as BinaryExpression
+        val assignValue3 = (stmts[9] as Assignment).value as BinaryExpression
+        assignValue1.operator shouldBe "^"
         assignValue2.operator shouldBe "^"
         assignValue3.operator shouldBe "&"
         val right2 = assignValue2.right as BinaryExpression

compiler/test/ast/TestIntermediateAst.kt

@@ -5,7 +5,7 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.ints.shouldBeGreaterThan
 import io.kotest.matchers.shouldBe
 import prog8.code.ast.*
-import prog8.code.core.*
+import prog8.code.core.DataType
 import prog8.code.target.C64Target
 import prog8.compiler.astprocessing.IntermediateAstMaker
 import prog8tests.helpers.compileText
@@ -26,18 +26,8 @@ class TestIntermediateAst: FunSpec({
             }
         """
         val target = C64Target()
-        val options = CompilationOptions(
-            OutputType.RAW,
-            CbmPrgLauncherType.NONE,
-            ZeropageType.DONTUSE,
-            emptyList(),
-            floats = false,
-            noSysInit = true,
-            compTarget = target,
-            loadAddress = target.machine.PROGRAM_LOAD_ADDRESS
-        )
         val result = compileText(target, false, text, writeAssembly = false)!!
-        val ast = IntermediateAstMaker(result.compilerAst, options).transform()
+        val ast = IntermediateAstMaker(result.compilerAst).transform()
         ast.name shouldBe result.compilerAst.name
         ast.allBlocks().any() shouldBe true
         val entry = ast.entrypoint() ?: fail("no main.start() found")

compiler/test/ast/TestProg8Parser.kt

@@ -19,6 +19,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.code.core.*
 import prog8.code.target.C64Target
+import prog8.code.target.VMTarget
 import prog8.code.target.cbm.PetsciiEncoding
 import prog8.parser.ParseError
 import prog8.parser.Prog8Parser.parseModule
@@ -378,7 +379,7 @@ class TestProg8Parser: FunSpec( {
             """.trimIndent()
             val module = parseModule(SourceCode.Text(srcText))
             assertSomethingForAllNodes(module) {
-                it.position.file shouldStartWith SourceCode.stringSourcePrefix
+                it.position.file shouldStartWith SourceCode.STRINGSOURCEPREFIX
             }
         }
 
@@ -387,7 +388,7 @@ class TestProg8Parser: FunSpec( {
             val resource = SourceCode.Resource("prog8lib/math.p8")
             val module = parseModule(resource)
             assertSomethingForAllNodes(module) {
-                it.position.file shouldStartWith SourceCode.libraryFilePrefix
+                it.position.file shouldStartWith SourceCode.LIBRARYFILEPREFIX
             }
         }
     }
@@ -984,4 +985,44 @@ main {
 
         compileText(C64Target(),  false, src, writeAssembly = false) shouldNotBe null
     }
+
+    test("various alternative curly brace styles are ok") {
+        val src="""
+%zeropage dontuse
+
+main {
+    ; curly braces without newline
+    sub start () { foo() derp() other() }
+    sub foo() { cx16.r0++ }
+    asmsub derp() { %asm {{ nop }} %ir {{ load.b r0,1 }} }
+
+    ; curly braces on next line
+    sub other()
+    {
+        cx16.r0++
+        asmother()
+        asmir()
+    }
+
+    asmsub asmother()
+    {
+        %asm
+        {{
+            txa
+            tay
+        }}
+    }
+
+    asmsub asmir()
+    {
+        %ir
+        {{
+            load.b r0,1
+        }}
+    }
+}"""
+
+        compileText(VMTarget(),  false, src, writeAssembly = false) shouldNotBe null
+    }
+
 })

compiler/test/ast/TestSourceCode.kt

@@ -5,7 +5,7 @@ import io.kotest.core.spec.style.AnnotationSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldContain
 import prog8.code.core.SourceCode
-import prog8.code.core.SourceCode.Companion.libraryFilePrefix
+import prog8.code.core.SourceCode.Companion.LIBRARYFILEPREFIX
 import prog8tests.helpers.assumeNotExists
 import prog8tests.helpers.assumeReadableFile
 import prog8tests.helpers.fixturesDir
@@ -77,7 +77,7 @@ class TestSourceCode: AnnotationSpec() {
         val srcFile = assumeReadableFile(resourcesDir, pathString).toFile()
         val src = SourceCode.Resource(pathString)
 
-        src.origin shouldBe "$libraryFilePrefix/$pathString"
+        src.origin shouldBe "$LIBRARYFILEPREFIX/$pathString"
         src.text shouldBe srcFile.readText()
         src.isFromResources shouldBe true
         src.isFromFilesystem shouldBe false
@@ -89,7 +89,7 @@ class TestSourceCode: AnnotationSpec() {
         val srcFile = assumeReadableFile(resourcesDir, pathString.substring(1)).toFile()
         val src = SourceCode.Resource(pathString)
 
-        src.origin shouldBe "$libraryFilePrefix$pathString"
+        src.origin shouldBe "$LIBRARYFILEPREFIX$pathString"
         src.text shouldBe srcFile.readText()
     }
 
@@ -99,7 +99,7 @@ class TestSourceCode: AnnotationSpec() {
         val srcFile = assumeReadableFile(resourcesDir, pathString).toFile()
         val src = SourceCode.Resource(pathString)
 
-        src.origin shouldBe "$libraryFilePrefix/$pathString"
+        src.origin shouldBe "$LIBRARYFILEPREFIX/$pathString"
         src.text shouldBe srcFile.readText()
         src.isFromResources shouldBe true
     }
@@ -110,7 +110,7 @@ class TestSourceCode: AnnotationSpec() {
         val srcFile = assumeReadableFile(resourcesDir, pathString.substring(1)).toFile()
         val src = SourceCode.Resource(pathString)
 
-        src.origin shouldBe "$libraryFilePrefix$pathString"
+        src.origin shouldBe "$LIBRARYFILEPREFIX$pathString"
         src.text shouldBe srcFile.readText()
     }
 
@@ -120,7 +120,7 @@ class TestSourceCode: AnnotationSpec() {
         val srcFile = assumeReadableFile(resourcesDir, pathString.substring(1)).toFile()
         val src = SourceCode.Resource(pathString)
 
-        src.origin shouldBe "$libraryFilePrefix/prog8lib/math.p8"
+        src.origin shouldBe "$LIBRARYFILEPREFIX/prog8lib/math.p8"
         src.text shouldBe srcFile.readText()
         src.isFromResources shouldBe true
     }

compiler/test/ast/TestVariousCompilerAst.kt

@@ -351,5 +351,20 @@ main
 
         compileText(VMTarget(), optimize=false, src, writeAssembly=false) shouldNotBe null
     }
+
+    test("char as str param is error") {
+        val src = """
+main {
+    sub start() {
+        print('@')
+    }
+
+    sub print(str message) {
+    }
+}"""
+        val errors = ErrorReporterForTests()
+        compileText(VMTarget(), optimize=false, src, writeAssembly=false, errors = errors) shouldBe null
+        errors.errors.single() shouldContain  "cannot use byte value"
+    }
 })