register params support for normal subroutines

codeCore/src/prog8/code/SymbolTable.kt

@@ -266,7 +266,7 @@ class StExtSub(name: String,
 
 
 
-class StSubroutineParameter(val name: String, val type: DataType)
+class StSubroutineParameter(val name: String, val type: DataType, val register: RegisterOrPair?)
 class StExtSubParameter(val register: RegisterOrStatusflag, val type: DataType)
 class StArrayElement(val number: Double?, val addressOfSymbol: String?, val boolean: Boolean?) {
     init {

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -55,7 +55,7 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                 StMemVar(node.name, node.type, node.address, node.arraySize?.toInt(), node)
             }
             is PtSub -> {
-                val params = node.parameters.map {StSubroutineParameter(it.name, it.type) }
+                val params = node.parameters.map {StSubroutineParameter(it.name, it.type, it.register) }
                 StSub(node.name, params, node.returntype, node)
             }
             is PtVariable -> {

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

@@ -23,14 +23,14 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                     "&"
             }
             is PtArray -> {
-                val valuelist = node.children.map {
+                val valuelist = node.children.joinToString(", ") {
                     when (it) {
                         is PtBool -> it.toString()
                         is PtNumber -> it.number.toString()
                         is PtIdentifier -> it.name
                         else -> "?"
                     }
-                }.joinToString(", ")
+                }
                 "array len=${node.children.size} ${type(node.type)} [ $valuelist ]"
             }
             is PtArrayIndexer -> "<arrayindexer> ${type(node.type)} ${if(node.splitWords) "[splitwords]" else ""}"
@@ -121,7 +121,10 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 }
             }
             is PtSub -> {
-                val params = node.parameters.joinToString(", ") { "${it.type} ${it.name}" }
+                val params = node.parameters.joinToString(", ") {
+                    val reg = if(it.register!=null) "@${it.register}" else ""
+                    "${it.type} ${it.name} $reg"
+                }
                 var str = "sub ${node.name}($params) "
                 if(node.returntype!=null)
                     str += "-> ${node.returntype.name.lowercase()}"
@@ -156,7 +159,10 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
             is PtProgram -> "PROGRAM ${node.name}"
             is PtRepeatLoop -> "repeat"
             is PtReturn -> "return"
-            is PtSubroutineParameter -> "${node.type.name.lowercase()} ${node.name}"
+            is PtSubroutineParameter -> {
+                val reg = if(node.register!=null) "@${node.register}" else ""
+                "${node.type.name.lowercase()} ${node.name} $reg"
+            }
             is PtWhen -> "when"
             is PtWhenChoice -> {
                 if(node.isElse)

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

@@ -39,7 +39,7 @@ class PtSub(
 }
 
 
-class PtSubroutineParameter(name: String, val type: DataType, position: Position): PtNamedNode(name, position)
+class PtSubroutineParameter(name: String, val type: DataType, val register: RegisterOrPair?, position: Position): PtNamedNode(name, position)
 
 
 sealed interface IPtAssignment {

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

@@ -95,6 +95,17 @@ enum class RegisterOrPair {
         else -> throw IllegalArgumentException("no cpu hardware register for $this")
     }
 
+    fun asScopedNameVirtualReg(type: DataType?): List<String> {
+        require(this in Cx16VirtualRegisters)
+        val suffix = when(type) {
+            DataType.UBYTE, DataType.BOOL -> "L"
+            DataType.BYTE -> "sL"
+            DataType.WORD -> "s"
+            DataType.UWORD, null -> ""
+            else -> throw kotlin.IllegalArgumentException("invalid register param type")
+        }
+        return listOf("cx16", name.lowercase()+suffix)
+    }
 }       // only used in parameter and return value specs in asm subroutines
 
 enum class Statusflag {