added -esa option to override the evalstack location, and shift cx16.r0-r15 accordingly

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

@@ -20,6 +20,7 @@ class CompilationOptions(val output: OutputType,
                          var asmQuiet: Boolean = false,
                          var asmListfile: Boolean = false,
                          var experimentalCodegen: Boolean = false,
+                         var evalStackBaseAddress: UInt? = null,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()
 )

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

@@ -18,8 +18,8 @@ interface IMachineDefinition {
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
     val FLOAT_MEM_SIZE: Int
-    val ESTACK_LO: UInt
-    val ESTACK_HI: UInt
+    var ESTACK_LO: UInt
+    var ESTACK_HI: UInt
     val PROGRAM_LOAD_ADDRESS : UInt
 
     val opcodeNames: Set<String>
@@ -32,4 +32,9 @@ 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
+    }
 }

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

@@ -15,8 +15,8 @@ class AtariMachineDefinition: IMachineDefinition {
     override val PROGRAM_LOAD_ADDRESS = 0x2000u
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive      // TODO
-    override val ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive      // TODO
+    override var ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive      // TODO
+    override var ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive      // TODO
 
     override lateinit var zeropage: Zeropage
 

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

@@ -16,8 +16,8 @@ class C128MachineDefinition: IMachineDefinition {
     override val PROGRAM_LOAD_ADDRESS = 0x1c01u
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive
-    override val ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive
+    override var ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive
+    override var ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive
 
     override lateinit var zeropage: Zeropage
 

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

@@ -16,8 +16,8 @@ class C64MachineDefinition: IMachineDefinition {
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0xce00u     //  $ce00-$ceff inclusive
-    override val ESTACK_HI = 0xcf00u     //  $ce00-$ceff inclusive
+    override var ESTACK_LO = 0xce00u     //  $ce00-$ceff inclusive
+    override var ESTACK_HI = 0xcf00u     //  $ce00-$ceff inclusive
 
     override lateinit var zeropage: Zeropage
 

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

@@ -15,8 +15,8 @@ class CX16MachineDefinition: IMachineDefinition {
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
     // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x0400u        //  $0400-$04ff inclusive
-    override val ESTACK_HI = 0x0500u        //  $0500-$05ff inclusive
+    override var ESTACK_LO = 0x0400u        //  $0400-$04ff inclusive
+    override var ESTACK_HI = 0x0500u        //  $0500-$05ff inclusive
 
     override lateinit var zeropage: Zeropage
 

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

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

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

@@ -135,6 +135,8 @@ class AstToXmlConverter(internal val program: PtProgram,
         xml.attr("nosysinit", options.noSysInit.toString())
         xml.attr("dontreinitglobals", options.dontReinitGlobals.toString())
         xml.attr("optimize", options.optimize.toString())
+        if(options.evalStackBaseAddress!=null)
+            xml.attr("evalstackbase", options.evalStackBaseAddress!!.toString())
         if(options.zpReserved.isNotEmpty()) {
             xml.startChildren()
             options.zpReserved.forEach {

codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt

@@ -60,6 +60,8 @@ class CodeGen(internal val program: PtProgram,
 
         if(options.symbolDefs.isNotEmpty())
             throw AssemblyError("virtual target doesn't support symbols defined on the commandline")
+        if(options.evalStackBaseAddress!=null)
+            throw AssemblyError("virtual target doesn't use eval-stack")
 
         for (block in program.allBlocks()) {
             vmprog.addBlock(translate(block))

compiler/res/prog8lib/c128/syslib.p8

@@ -722,6 +722,7 @@ cx16 {
     ; $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

compiler/res/prog8lib/c64/syslib.p8

@@ -685,6 +685,7 @@ cx16 {
     ; (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

compiler/res/prog8lib/virtual/syslib.p8

@@ -110,7 +110,6 @@ cx16 {
 
     ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
     ; they are simulated on the VirtualMachine as well but their location in memory is different
-; the sixteen virtual 16-bit registers in both normal unsigned mode and signed mode (s)
     &uword r0  = $0002
     &uword r1  = $0004
     &uword r2  = $0006

compiler/src/prog8/CompilerMain.kt

@@ -3,6 +3,7 @@ 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
@@ -17,7 +18,6 @@ import java.time.LocalDateTime
 import kotlin.system.exitProcess
 
 
-
 fun main(args: Array<String>) {
     val buildVersion = object {}.javaClass.getResource("/version.txt")?.readText()?.trim()
     println("\nProg8 compiler v$buildVersion by Irmen de Jong (irmen@razorvine.net)")
@@ -49,7 +49,8 @@ private fun compileMain(args: Array<String>): Boolean {
     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}')").default(C64Target.NAME)
     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 startVm by cli.option(ArgType.Boolean, fullName = "vm", description = "load and run a p8-virt listing in the VM instead")
-    val symbolDefs by cli.option(ArgType.String, fullName = "D", description = "define assembly symbol(s) like -D SYMBOL=VALUE").multiple()
+    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 moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
     try {
@@ -84,6 +85,25 @@ 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) {
@@ -106,6 +126,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     asmListfile == true,
                     experimentalCodegen == true,
                     compilationTarget,
+                    evalStackAddr,
                     processedSymbols,
                     srcdirs,
                     outputPath
@@ -159,6 +180,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     asmListfile == true,
                     experimentalCodegen == true,
                     compilationTarget,
+                    evalStackAddr,
                     processedSymbols,
                     srcdirs,
                     outputPath

compiler/src/prog8/compiler/Compiler.kt

@@ -38,6 +38,7 @@ class CompilerArguments(val filepath: Path,
                         val asmListfile: Boolean,
                         val experimentalCodegen: Boolean,
                         val compilationTarget: String,
+                        val evalStackBaseAddress: UInt?,
                         val symbolDefs: Map<String, String>,
                         val sourceDirs: List<String> = emptyList(),
                         val outputDir: Path = Path(""),
@@ -78,11 +79,17 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
                 asmQuiet = args.quietAssembler
                 asmListfile = args.asmListfile
                 experimentalCodegen = args.experimentalCodegen
+                evalStackBaseAddress = args.evalStackBaseAddress
                 outputDir = args.outputDir.normalize()
                 symbolDefs = args.symbolDefs
             }
             program = programresult
             importedFiles = imported
+
+            if(compilationOptions.evalStackBaseAddress!=null) {
+                compTarget.machine.overrideEvalStack(compilationOptions.evalStackBaseAddress!!)
+            }
+
             processAst(program, args.errors, compilationOptions)
             if (compilationOptions.optimize) {
 //                println("*********** AST RIGHT BEFORE OPTIMIZING *************")

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

@@ -8,10 +8,44 @@ import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
+import prog8.code.target.Cx16Target
 
 
 class AstPreprocessor(val program: Program, val errors: IErrorReporter, val compTarget: ICompilationTarget) : AstWalker() {
 
+    override fun before(program: Program): Iterable<IAstModification> {
+        if(compTarget.name!=Cx16Target.NAME) {
+            // 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>()
+                .associateBy { it.name }
+
+            val estack = compTarget.machine.ESTACK_HI
+            for(regnum in 0u..15u) {
+                val rX = memVars.getValue("r$regnum")
+                val rXL = memVars.getValue("r${regnum}L")
+                val rXH = memVars.getValue("r${regnum}H")
+                val rXs = memVars.getValue("r${regnum}s")
+                val rXsL = memVars.getValue("r${regnum}sL")
+                val rXsH = memVars.getValue("r${regnum}sH")
+                setAddress(rX, estack + 2u*regnum)
+                setAddress(rXL, estack + 2u*regnum)
+                setAddress(rXH, estack + 2u*regnum +1u)
+                setAddress(rXs, estack + 2u*regnum)
+                setAddress(rXsL, estack + 2u*regnum)
+                setAddress(rXsH, estack + 2u*regnum + 1u)
+            }
+        }
+        return noModifications
+    }
+
+    private fun setAddress(vardecl: VarDecl, address: UInt) {
+        val oldAddr = vardecl.value as NumericLiteral
+        vardecl.value = NumericLiteral(oldAddr.type, address.toDouble(), oldAddr.position)
+    }
+
     override fun before(char: CharLiteral, parent: Node): Iterable<IAstModification> {
         if(char.encoding== Encoding.DEFAULT)
             char.encoding = compTarget.defaultEncoding

compiler/test/TestCompilerOnExamples.kt

@@ -37,6 +37,7 @@ private fun compileTheThing(filepath: Path, optimize: Boolean, target: ICompilat
         asmListfile = false,
         experimentalCodegen = false,
         compilationTarget = target.name,
+        evalStackBaseAddress = null,
         symbolDefs = emptyMap(),
         outputDir = outputDir
     )

compiler/test/TestCompilerOptionLibdirs.kt

@@ -51,6 +51,7 @@ class TestCompilerOptionSourcedirs: FunSpec({
             asmListfile = false,
             experimentalCodegen = false,
             compilationTarget = Cx16Target.NAME,
+            evalStackBaseAddress = null,
             symbolDefs = emptyMap(),
             sourceDirs,
             outputDir

compiler/test/helpers/compileXyz.kt

@@ -37,6 +37,7 @@ internal fun compileFile(
         asmListfile = false,
         experimentalCodegen = false,
         platform.name,
+        evalStackBaseAddress = null,
         symbolDefs = emptyMap(),
         outputDir = outputDir,
         errors = errors ?: ErrorReporterForTests()

docs/source/building.rst

@@ -164,6 +164,12 @@ One or more .p8 module files
     Add this user-defined symbol directly to the beginning of the generated assembly file.
     Can be repeated to define multiple symbols.
 
+``-esa <address>``
+    Override the base address of the evaluation stack. Has to be page-aligned.
+    You can specify an integer or hexadecimal address.
+    When not compiling for the CommanderX16 target, the location of the 16 virtual registers cx16.r0..r15
+    is changed accordingly (to keep them in the same memory space as the evaluation stack).
+
 
 Module source code files
 ------------------------

docs/source/todo.rst

@@ -3,9 +3,6 @@ TODO
 
 For next release
 ^^^^^^^^^^^^^^^^
-- have a proper option to move the evalstack rather than just assembly symbol redefine
-- then make the cx16 virtual registers in syslib.p8 use that definition to be able to shift them around on non-cx16 targets
-
 ...
 
 

httpCompilerService/src/prog8/http/TestHttp.kt

@@ -38,6 +38,7 @@ class RequestParser : Take {
             writeAssembly = true,
             slowCodegenWarnings = true,
             compilationTarget = "c64",
+            evalStackBaseAddress = null,
             symbolDefs = emptyMap(),
             quietAssembler = false,
             asmListfile = false,