Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-07-29 10:29:37 +00:00
Code Issues Projects Releases Wiki Activity

separate varnames and other symbol names

Browse Source
This commit is contained in:
Irmen de Jong 2020-08-25 22:08:52 +02:00
parent 3ce692bb10
commit 19705196d6
9 changed files with 90 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
View File

@ -270,12 +270,13 @@ internal class AsmGen(private val program: Program,
} }
private fun vardecl2asm(decl: VarDecl) { private fun vardecl2asm(decl: VarDecl) {
val name = decl.name
when (decl.datatype) { when (decl.datatype) {
DataType.UBYTE -> out("${decl.name}\t.byte 0") DataType.UBYTE -> out("$name\t.byte 0")
DataType.BYTE -> out("${decl.name}\t.char 0") DataType.BYTE -> out("$name\t.char 0")
DataType.UWORD -> out("${decl.name}\t.word 0") DataType.UWORD -> out("$name\t.word 0")
DataType.WORD -> out("${decl.name}\t.sint 0") DataType.WORD -> out("$name\t.sint 0")
DataType.FLOAT -> out("${decl.name}\t.byte 0,0,0,0,0 ; float") DataType.FLOAT -> out("$name\t.byte 0,0,0,0,0 ; float")
DataType.STRUCT -> {} // is flattened DataType.STRUCT -> {} // is flattened
DataType.STR -> { DataType.STR -> {
val str = decl.value as StringLiteralValue val str = decl.value as StringLiteralValue
@ -284,9 +285,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_UB -> { DataType.ARRAY_UB -> {
val data = makeArrayFillDataUnsigned(decl) val data = makeArrayFillDataUnsigned(decl)
if (data.size <= 16) if (data.size <= 16)
out("${decl.name}\t.byte ${data.joinToString()}") out("$name\t.byte ${data.joinToString()}")
else { else {
out(decl.name) out(name)
for (chunk in data.chunked(16)) for (chunk in data.chunked(16))
out(" .byte " + chunk.joinToString()) out(" .byte " + chunk.joinToString())
} }
@ -294,9 +295,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_B -> { DataType.ARRAY_B -> {
val data = makeArrayFillDataSigned(decl) val data = makeArrayFillDataSigned(decl)
if (data.size <= 16) if (data.size <= 16)
out("${decl.name}\t.char ${data.joinToString()}") out("$name\t.char ${data.joinToString()}")
else { else {
out(decl.name) out(name)
for (chunk in data.chunked(16)) for (chunk in data.chunked(16))
out(" .char " + chunk.joinToString()) out(" .char " + chunk.joinToString())
} }
@ -304,9 +305,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_UW -> { DataType.ARRAY_UW -> {
val data = makeArrayFillDataUnsigned(decl) val data = makeArrayFillDataUnsigned(decl)
if (data.size <= 16) if (data.size <= 16)
out("${decl.name}\t.word ${data.joinToString()}") out("$name\t.word ${data.joinToString()}")
else { else {
out(decl.name) out(name)
for (chunk in data.chunked(16)) for (chunk in data.chunked(16))
out(" .word " + chunk.joinToString()) out(" .word " + chunk.joinToString())
} }
@ -314,9 +315,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_W -> { DataType.ARRAY_W -> {
val data = makeArrayFillDataSigned(decl) val data = makeArrayFillDataSigned(decl)
if (data.size <= 16) if (data.size <= 16)
out("${decl.name}\t.sint ${data.joinToString()}") out("$name\t.sint ${data.joinToString()}")
else { else {
out(decl.name) out(name)
for (chunk in data.chunked(16)) for (chunk in data.chunked(16))
out(" .sint " + chunk.joinToString()) out(" .sint " + chunk.joinToString())
} }
@ -334,7 +335,7 @@ internal class AsmGen(private val program: Program,
val number = (it as NumericLiteralValue).number val number = (it as NumericLiteralValue).number
CompilationTarget.machine.getFloat(number).makeFloatFillAsm() CompilationTarget.machine.getFloat(number).makeFloatFillAsm()
} }
out(decl.name) out(name)
for (f in array.zip(floatFills)) for (f in array.zip(floatFills))
out(" .byte ${f.second} ; float ${f.first}") out(" .byte ${f.second} ; float ${f.first}")
} }
@ -478,24 +479,33 @@ internal class AsmGen(private val program: Program,
return asmName return asmName
} }
internal fun asmIdentifierName(identifier: IdentifierReference): String { internal fun asmSymbolName(identifier: IdentifierReference): String {
val name = if(identifier.memberOfStruct(program.namespace)!=null) { return if(identifier.memberOfStruct(program.namespace)!=null) {
identifier.targetVarDecl(program.namespace)!!.name val name = identifier.targetVarDecl(program.namespace)!!.name
fixNameSymbols(name)
} else { } else {
identifier.nameInSource.joinToString(".") fixNameSymbols(identifier.nameInSource.joinToString("."))
}
}
internal fun asmVariableName(identifier: IdentifierReference): String {
return if(identifier.memberOfStruct(program.namespace)!=null) {
val name = identifier.targetVarDecl(program.namespace)!!.name
fixNameSymbols(name)
} else {
fixNameSymbols(identifier.nameInSource.joinToString("."))
} }
return fixNameSymbols(name)
} }
internal fun loadByteFromPointerIntoA(pointervar: IdentifierReference): Pair<Boolean, String> { internal fun loadByteFromPointerIntoA(pointervar: IdentifierReference): Pair<Boolean, String> {
// returns if the pointer is already on the ZP itself or not (in which case SCRATCH_W1 is used as intermediary) // returns if the pointer is already on the ZP itself or not (in which case SCRATCH_W1 is used as intermediary)
val sourceName = asmIdentifierName(pointervar) val sourceName = asmVariableName(pointervar)
val vardecl = pointervar.targetVarDecl(program.namespace)!! val vardecl = pointervar.targetVarDecl(program.namespace)!!
val scopedName = vardecl.makeScopedName(vardecl.name) val scopedName = vardecl.makeScopedName(vardecl.name)
if(scopedName in allocatedZeropageVariables) { return if(scopedName in allocatedZeropageVariables) {
// pointervar is already in the zero page, no need to copy // pointervar is already in the zero page, no need to copy
out(" ldy #0 | lda ($sourceName),y") out(" ldy #0 | lda ($sourceName),y")
return Pair(true, sourceName) Pair(true, sourceName)
} else { } else {
out(""" out("""
lda $sourceName lda $sourceName
@ -504,12 +514,12 @@ internal class AsmGen(private val program: Program,
sty P8ZP_SCRATCH_W1+1 sty P8ZP_SCRATCH_W1+1
ldy #0 ldy #0
lda (P8ZP_SCRATCH_W1),y""") lda (P8ZP_SCRATCH_W1),y""")
return Pair(false, sourceName) Pair(false, sourceName)
} }
} }
fun storeByteIntoPointer(pointervar: IdentifierReference, ldaInstructionArg: String?) { fun storeByteIntoPointer(pointervar: IdentifierReference, ldaInstructionArg: String?) {
val sourceName = asmIdentifierName(pointervar) val sourceName = asmVariableName(pointervar)
val vardecl = pointervar.targetVarDecl(program.namespace)!! val vardecl = pointervar.targetVarDecl(program.namespace)!!
val scopedName = vardecl.makeScopedName(vardecl.name) val scopedName = vardecl.makeScopedName(vardecl.name)
if(scopedName in allocatedZeropageVariables) { if(scopedName in allocatedZeropageVariables) {
@ -613,7 +623,7 @@ internal class AsmGen(private val program: Program,
if(addOneExtra) { if(addOneExtra) {
// add 1 to the result // add 1 to the result
if (index is IdentifierReference) { if (index is IdentifierReference) {
val indexName = asmIdentifierName(index) val indexName = asmVariableName(index)
when(elementDt) { when(elementDt) {
in ByteDatatypes -> { in ByteDatatypes -> {
out(" ldy $indexName | iny") out(" ldy $indexName | iny")
@ -663,7 +673,7 @@ internal class AsmGen(private val program: Program,
} }
} else { } else {
if (index is IdentifierReference) { if (index is IdentifierReference) {
val indexName = asmIdentifierName(index) val indexName = asmVariableName(index)
when(elementDt) { when(elementDt) {
in ByteDatatypes -> out(" ld$reg $indexName") in ByteDatatypes -> out(" ld$reg $indexName")
in WordDatatypes -> { in WordDatatypes -> {
@ -817,7 +827,7 @@ internal class AsmGen(private val program: Program,
} }
is IdentifierReference -> { is IdentifierReference -> {
val vardecl = (stmt.iterations as IdentifierReference).targetStatement(program.namespace) as VarDecl val vardecl = (stmt.iterations as IdentifierReference).targetStatement(program.namespace) as VarDecl
val name = asmIdentifierName(stmt.iterations as IdentifierReference) val name = asmVariableName(stmt.iterations as IdentifierReference)
when(vardecl.datatype) { when(vardecl.datatype) {
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
out(" lda $name") out(" lda $name")
@ -1088,7 +1098,7 @@ $counterVar .byte 0""")
return when { return when {
jmp.identifier!=null -> { jmp.identifier!=null -> {
val target = jmp.identifier.targetStatement(program.namespace) val target = jmp.identifier.targetStatement(program.namespace)
val asmName = asmIdentifierName(jmp.identifier) val asmName = asmSymbolName(jmp.identifier)
if(target is Label) if(target is Label)
"_$asmName" // prefix with underscore to jump to local label "_$asmName" // prefix with underscore to jump to local label
else else

32
compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
View File

@ -72,7 +72,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
val variable = fcall.args.single() val variable = fcall.args.single()
if (variable is IdentifierReference) { if (variable is IdentifierReference) {
val decl = variable.targetVarDecl(program.namespace)!! val decl = variable.targetVarDecl(program.namespace)!!
val varName = asmgen.asmIdentifierName(variable) val varName = asmgen.asmVariableName(variable)
val numElements = decl.arraysize!!.constIndex() val numElements = decl.arraysize!!.constIndex()
when (decl.datatype) { when (decl.datatype) {
DataType.ARRAY_UB, DataType.ARRAY_B -> { DataType.ARRAY_UB, DataType.ARRAY_B -> {
@ -114,7 +114,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
val variable = fcall.args.single() val variable = fcall.args.single()
if (variable is IdentifierReference) { if (variable is IdentifierReference) {
val decl = variable.targetVarDecl(program.namespace)!! val decl = variable.targetVarDecl(program.namespace)!!
val varName = asmgen.asmIdentifierName(variable) val varName = asmgen.asmVariableName(variable)
val numElements = decl.arraysize!!.constIndex() val numElements = decl.arraysize!!.constIndex()
when (decl.datatype) { when (decl.datatype) {
DataType.ARRAY_UB, DataType.ARRAY_B -> { DataType.ARRAY_UB, DataType.ARRAY_B -> {
@ -167,7 +167,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" lda $variable | lsr a | bcc + | ora #\$80 |+ | sta $variable") asmgen.out(" lda $variable | lsr a | bcc + | ora #\$80 |+ | sta $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -181,7 +181,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
asmgen.out(" jsr prog8_lib.ror2_array_uw") asmgen.out(" jsr prog8_lib.ror2_array_uw")
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" lsr $variable+1 | ror $variable | bcc + | lda $variable+1 | ora #\$80 | sta $variable+1 |+ ") asmgen.out(" lsr $variable+1 | ror $variable | bcc + | lda $variable+1 | ora #\$80 | sta $variable+1 |+ ")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -219,7 +219,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" ror $variable") asmgen.out(" ror $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -233,7 +233,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
asmgen.out(" jsr prog8_lib.ror_array_uw") asmgen.out(" jsr prog8_lib.ror_array_uw")
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" ror $variable+1 | ror $variable") asmgen.out(" ror $variable+1 | ror $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -264,7 +264,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" lda $variable | cmp #\$80 | rol a | sta $variable") asmgen.out(" lda $variable | cmp #\$80 | rol a | sta $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -278,7 +278,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
asmgen.out(" jsr prog8_lib.rol2_array_uw") asmgen.out(" jsr prog8_lib.rol2_array_uw")
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" asl $variable | rol $variable+1 | bcc + | inc $variable |+ ") asmgen.out(" asl $variable | rol $variable+1 | bcc + | inc $variable |+ ")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -316,7 +316,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" rol $variable") asmgen.out(" rol $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -330,7 +330,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
asmgen.out(" jsr prog8_lib.rol_array_uw") asmgen.out(" jsr prog8_lib.rol_array_uw")
} }
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmVariableName(what)
asmgen.out(" rol $variable | rol $variable+1") asmgen.out(" rol $variable | rol $variable+1")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
@ -383,7 +383,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
private fun funcStrlen(fcall: IFunctionCall) { private fun funcStrlen(fcall: IFunctionCall) {
val name = asmgen.asmIdentifierName(fcall.args[0] as IdentifierReference) val name = asmgen.asmVariableName(fcall.args[0] as IdentifierReference)
asmgen.out(""" asmgen.out("""
lda #<$name lda #<$name
ldy #>$name ldy #>$name
@ -396,8 +396,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
val first = fcall.args[0] val first = fcall.args[0]
val second = fcall.args[1] val second = fcall.args[1]
if(first is IdentifierReference && second is IdentifierReference) { if(first is IdentifierReference && second is IdentifierReference) {
val firstName = asmgen.asmIdentifierName(first) val firstName = asmgen.asmVariableName(first)
val secondName = asmgen.asmIdentifierName(second) val secondName = asmgen.asmVariableName(second)
val dt = first.inferType(program) val dt = first.inferType(program)
if(dt.istype(DataType.BYTE) || dt.istype(DataType.UBYTE)) { if(dt.istype(DataType.BYTE) || dt.istype(DataType.UBYTE)) {
asmgen.out(" ldy $firstName | lda $secondName | sta $firstName | tya | sta $secondName") asmgen.out(" ldy $firstName | lda $secondName | sta $firstName | tya | sta $secondName")
@ -461,7 +461,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
if (arg is NumericLiteralValue) if (arg is NumericLiteralValue)
throw AssemblyError("msb(const) should have been const-folded away") throw AssemblyError("msb(const) should have been const-folded away")
if (arg is IdentifierReference) { if (arg is IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(arg) val sourceName = asmgen.asmVariableName(arg)
asmgen.out(" lda $sourceName+1 | sta P8ESTACK_LO,x | dex") asmgen.out(" lda $sourceName+1 | sta P8ESTACK_LO,x | dex")
} else { } else {
asmgen.translateExpression(arg) asmgen.translateExpression(arg)
@ -476,7 +476,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
if (arg is NumericLiteralValue) if (arg is NumericLiteralValue)
throw AssemblyError("lsb(const) should have been const-folded away") throw AssemblyError("lsb(const) should have been const-folded away")
if (arg is IdentifierReference) { if (arg is IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(arg) val sourceName = asmgen.asmVariableName(arg)
asmgen.out(" lda $sourceName | sta P8ESTACK_LO,x | dex") asmgen.out(" lda $sourceName | sta P8ESTACK_LO,x | dex")
} else { } else {
asmgen.translateExpression(arg) asmgen.translateExpression(arg)
@ -486,7 +486,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
private fun outputPushAddressAndLenghtOfArray(arg: Expression) { private fun outputPushAddressAndLenghtOfArray(arg: Expression) {
arg as IdentifierReference arg as IdentifierReference
val identifierName = asmgen.asmIdentifierName(arg) val identifierName = asmgen.asmVariableName(arg)
val size = arg.targetVarDecl(program.namespace)!!.arraysize!!.constIndex()!! val size = arg.targetVarDecl(program.namespace)!!.arraysize!!.constIndex()!!
asmgen.out(""" asmgen.out("""
lda #<$identifierName lda #<$identifierName

6
compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
View File

@ -127,7 +127,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
} }
private fun translateExpression(expr: AddressOf) { private fun translateExpression(expr: AddressOf) {
val name = asmgen.asmIdentifierName(expr.identifier) val name = asmgen.asmVariableName(expr.identifier)
asmgen.out(" lda #<$name | sta P8ESTACK_LO,x | lda #>$name | sta P8ESTACK_HI,x | dex") asmgen.out(" lda #<$name | sta P8ESTACK_LO,x | lda #>$name | sta P8ESTACK_HI,x | dex")
} }
@ -169,7 +169,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
} }
private fun translateExpression(expr: IdentifierReference) { private fun translateExpression(expr: IdentifierReference) {
val varname = asmgen.asmIdentifierName(expr) val varname = asmgen.asmVariableName(expr)
when(expr.inferType(program).typeOrElse(DataType.STRUCT)) { when(expr.inferType(program).typeOrElse(DataType.STRUCT)) {
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
asmgen.out(" lda $varname | sta P8ESTACK_LO,x | dex") asmgen.out(" lda $varname | sta P8ESTACK_LO,x | dex")
@ -381,7 +381,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
private fun translateExpression(arrayExpr: ArrayIndexedExpression) { private fun translateExpression(arrayExpr: ArrayIndexedExpression) {
val index = arrayExpr.arrayspec.index val index = arrayExpr.arrayspec.index
val elementDt = arrayExpr.inferType(program).typeOrElse(DataType.STRUCT) val elementDt = arrayExpr.inferType(program).typeOrElse(DataType.STRUCT)
val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier) val arrayVarName = asmgen.asmVariableName(arrayExpr.identifier)
if(index is NumericLiteralValue) { if(index is NumericLiteralValue) {
val indexValue = index.number.toInt() * elementDt.memorySize() val indexValue = index.number.toInt() * elementDt.memorySize()
when(elementDt) { when(elementDt) {

30
compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt
View File

@ -50,7 +50,7 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
val incdec = if(stepsize==1) "inc" else "dec" val incdec = if(stepsize==1) "inc" else "dec"
// loop over byte range via loopvar // loop over byte range via loopvar
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.translateExpression(range.to) asmgen.translateExpression(range.to)
asmgen.translateExpression(range.from) asmgen.translateExpression(range.from)
asmgen.out(""" asmgen.out("""
@ -74,7 +74,7 @@ $endLabel inx""")
// bytes, step >= 2 or <= -2 // bytes, step >= 2 or <= -2
// loop over byte range via loopvar // loop over byte range via loopvar
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.translateExpression(range.to) asmgen.translateExpression(range.to)
asmgen.translateExpression(range.from) asmgen.translateExpression(range.from)
asmgen.out(""" asmgen.out("""
@ -115,7 +115,7 @@ $endLabel inx""")
stepsize == 1 || stepsize == -1 -> { stepsize == 1 || stepsize == -1 -> {
asmgen.translateExpression(range.to) asmgen.translateExpression(range.to)
assignLoopvar(stmt, range) assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda P8ESTACK_HI+1,x lda P8ESTACK_HI+1,x
sta $modifiedLabel+1 sta $modifiedLabel+1
@ -159,7 +159,7 @@ $modifiedLabel2 cmp #0 ; modified
sta $modifiedLabel2+1 sta $modifiedLabel2+1
""") """)
assignLoopvar(stmt, range) assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(loopLabel) asmgen.out(loopLabel)
asmgen.translate(stmt.body) asmgen.translate(stmt.body)
@ -210,7 +210,7 @@ $endLabel inx""")
sta $modifiedLabel2+1 sta $modifiedLabel2+1
""") """)
assignLoopvar(stmt, range) assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(loopLabel) asmgen.out(loopLabel)
asmgen.translate(stmt.body) asmgen.translate(stmt.body)
@ -269,7 +269,7 @@ $endLabel inx""")
val loopLabel = asmgen.makeLabel("for_loop") val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end") val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel) asmgen.loopEndLabels.push(endLabel)
val iterableName = asmgen.asmIdentifierName(ident) val iterableName = asmgen.asmVariableName(ident)
val decl = ident.targetVarDecl(program.namespace)!! val decl = ident.targetVarDecl(program.namespace)!!
when(iterableDt) { when(iterableDt) {
DataType.STR -> { DataType.STR -> {
@ -280,7 +280,7 @@ $endLabel inx""")
sty $loopLabel+2 sty $loopLabel+2
$loopLabel lda ${65535.toHex()} ; modified $loopLabel lda ${65535.toHex()} ; modified
beq $endLabel beq $endLabel
sta ${asmgen.asmIdentifierName(stmt.loopVar)}""") sta ${asmgen.asmVariableName(stmt.loopVar)}""")
asmgen.translate(stmt.body) asmgen.translate(stmt.body)
asmgen.out(""" asmgen.out("""
inc $loopLabel+1 inc $loopLabel+1
@ -296,7 +296,7 @@ $endLabel""")
ldy #0 ldy #0
$loopLabel sty $indexVar $loopLabel sty $indexVar
lda $iterableName,y lda $iterableName,y
sta ${asmgen.asmIdentifierName(stmt.loopVar)}""") sta ${asmgen.asmVariableName(stmt.loopVar)}""")
asmgen.translate(stmt.body) asmgen.translate(stmt.body)
if(length<=255) { if(length<=255) {
asmgen.out(""" asmgen.out("""
@ -326,7 +326,7 @@ $indexVar .byte 0""")
DataType.ARRAY_W, DataType.ARRAY_UW -> { DataType.ARRAY_W, DataType.ARRAY_UW -> {
val length = decl.arraysize!!.constIndex()!! * 2 val length = decl.arraysize!!.constIndex()!! * 2
val indexVar = asmgen.makeLabel("for_index") val indexVar = asmgen.makeLabel("for_index")
val loopvarName = asmgen.asmIdentifierName(stmt.loopVar) val loopvarName = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
ldy #0 ldy #0
$loopLabel sty $indexVar $loopLabel sty $indexVar
@ -389,7 +389,7 @@ $indexVar .byte 0""")
when(iterableDt) { when(iterableDt) {
DataType.ARRAY_B, DataType.ARRAY_UB -> { DataType.ARRAY_B, DataType.ARRAY_UB -> {
// loop over byte range via loopvar, step >= 2 or <= -2 // loop over byte range via loopvar, step >= 2 or <= -2
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda #${range.first} lda #${range.first}
sta $varname sta $varname
@ -454,7 +454,7 @@ $loopLabel""")
} }
DataType.ARRAY_W, DataType.ARRAY_UW -> { DataType.ARRAY_W, DataType.ARRAY_UW -> {
// loop over word range via loopvar, step >= 2 or <= -2 // loop over word range via loopvar, step >= 2 or <= -2
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
when (range.step) { when (range.step) {
0, 1, -1 -> { 0, 1, -1 -> {
throw AssemblyError("step 0, 1 and -1 should have been handled specifically $stmt") throw AssemblyError("step 0, 1 and -1 should have been handled specifically $stmt")
@ -498,7 +498,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop") val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end") val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel) asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda #${range.first} lda #${range.first}
sta $varname sta $varname
@ -525,7 +525,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop") val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end") val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel) asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda #${range.first} lda #${range.first}
sta $varname sta $varname
@ -563,7 +563,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop") val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end") val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel) asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda #<${range.first} lda #<${range.first}
ldy #>${range.first} ldy #>${range.first}
@ -591,7 +591,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop") val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end") val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel) asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar) val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(""" asmgen.out("""
lda #<${range.first} lda #<${range.first}
ldy #>${range.first} ldy #>${range.first}

4
compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
View File

@ -20,7 +20,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
if(saveX) if(saveX)
asmgen.out(" stx P8ZP_SCRATCH_REG_X") // we only save X for now (required! is the eval stack pointer), screw A and Y... asmgen.out(" stx P8ZP_SCRATCH_REG_X") // we only save X for now (required! is the eval stack pointer), screw A and Y...
val subName = asmgen.asmIdentifierName(stmt.target) val subName = asmgen.asmSymbolName(stmt.target)
if(stmt.args.isNotEmpty()) { if(stmt.args.isNotEmpty()) {
if(sub.asmParameterRegisters.isEmpty()) { if(sub.asmParameterRegisters.isEmpty()) {
// via variables // via variables
@ -139,7 +139,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
asmgen.out(if(carrySet) " sec" else " clc") asmgen.out(if(carrySet) " sec" else " clc")
} }
is IdentifierReference -> { is IdentifierReference -> {
val sourceName = asmgen.asmIdentifierName(value) val sourceName = asmgen.asmVariableName(value)
asmgen.out(""" asmgen.out("""
pha pha
lda $sourceName lda $sourceName

6
compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
View File

@ -17,7 +17,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
val targetArrayIdx = stmt.target.arrayindexed val targetArrayIdx = stmt.target.arrayindexed
when { when {
targetIdent!=null -> { targetIdent!=null -> {
val what = asmgen.asmIdentifierName(targetIdent) val what = asmgen.asmVariableName(targetIdent)
when (stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)) { when (stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)) {
in ByteDatatypes -> asmgen.out(if (incr) " inc $what" else " dec $what") in ByteDatatypes -> asmgen.out(if (incr) " inc $what" else " dec $what")
in WordDatatypes -> { in WordDatatypes -> {
@ -45,7 +45,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
asmgen.out(if(incr) " inc $what" else " dec $what") asmgen.out(if(incr) " inc $what" else " dec $what")
} }
is IdentifierReference -> { is IdentifierReference -> {
val what = asmgen.asmIdentifierName(addressExpr) val what = asmgen.asmVariableName(addressExpr)
asmgen.out(" lda $what | sta (+) +1 | lda $what+1 | sta (+) +2") asmgen.out(" lda $what | sta (+) +1 | lda $what+1 | sta (+) +2")
if(incr) if(incr)
asmgen.out("+\tinc ${'$'}ffff\t; modified") asmgen.out("+\tinc ${'$'}ffff\t; modified")
@ -70,7 +70,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
} }
targetArrayIdx!=null -> { targetArrayIdx!=null -> {
val index = targetArrayIdx.arrayspec.index val index = targetArrayIdx.arrayspec.index
val asmArrayvarname = asmgen.asmIdentifierName(targetArrayIdx.identifier) val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.identifier)
val elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT) val elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT)
when(index) { when(index) {
is NumericLiteralValue -> { is NumericLiteralValue -> {

4
compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt
View File

@ -44,9 +44,9 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! } val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! }
val asmVarname by lazy { val asmVarname by lazy {
if(variable!=null) if(variable!=null)
asmgen.asmIdentifierName(variable) asmgen.asmVariableName(variable)
else else
asmgen.asmIdentifierName(array!!.identifier) asmgen.asmVariableName(array!!.identifier)
} }
lateinit var origAssign: AsmAssignment lateinit var origAssign: AsmAssignment

14
compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
View File

@ -53,7 +53,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val value = assign.source.array!! val value = assign.source.array!!
val elementDt = assign.source.datatype val elementDt = assign.source.datatype
val index = value.arrayspec.index val index = value.arrayspec.index
val arrayVarName = asmgen.asmIdentifierName(value.identifier) val arrayVarName = asmgen.asmVariableName(value.identifier)
if (index is NumericLiteralValue) { if (index is NumericLiteralValue) {
// constant array index value // constant array index value
val indexValue = index.number.toInt() * elementDt.memorySize() val indexValue = index.number.toInt() * elementDt.memorySize()
@ -316,7 +316,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
} }
TargetStorageKind.STACK -> { TargetStorageKind.STACK -> {
val srcname = asmgen.asmIdentifierName(name) val srcname = asmgen.asmVariableName(name)
asmgen.out(""" asmgen.out("""
lda #<$srcname lda #<$srcname
sta P8ESTACK_LO,x sta P8ESTACK_LO,x
@ -328,7 +328,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
private fun assignVariableWord(target: AsmAssignTarget, variable: IdentifierReference) { private fun assignVariableWord(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable) val sourceName = asmgen.asmVariableName(variable)
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.out(""" asmgen.out("""
@ -432,7 +432,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
private fun assignVariableFloat(target: AsmAssignTarget, variable: IdentifierReference) { private fun assignVariableFloat(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable) val sourceName = asmgen.asmVariableName(variable)
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.out(""" asmgen.out("""
@ -467,7 +467,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
private fun assignVariableByte(target: AsmAssignTarget, variable: IdentifierReference) { private fun assignVariableByte(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable) val sourceName = asmgen.asmVariableName(variable)
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.out(""" asmgen.out("""
@ -542,7 +542,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
CpuRegister.X -> asmgen.out(" txa") CpuRegister.X -> asmgen.out(" txa")
CpuRegister.Y -> asmgen.out(" tya") CpuRegister.Y -> asmgen.out(" tya")
} }
asmgen.out(" ldy ${asmgen.asmIdentifierName(index)} | sta ${target.asmVarname},y") asmgen.out(" ldy ${asmgen.asmVariableName(index)} | sta ${target.asmVarname},y")
} }
else -> { else -> {
asmgen.saveRegister(register) asmgen.saveRegister(register)
@ -852,7 +852,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" sta ${target.asmVarname}") asmgen.out(" sta ${target.asmVarname}")
} }
TargetStorageKind.MEMORY -> { TargetStorageKind.MEMORY -> {
val sourceName = asmgen.asmIdentifierName(identifier) val sourceName = asmgen.asmVariableName(identifier)
storeByteViaRegisterAInMemoryAddress(sourceName, target.memory!!) storeByteViaRegisterAInMemoryAddress(sourceName, target.memory!!)
} }
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {

8
compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt
View File

@ -282,7 +282,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
if(valueDt != DataType.FLOAT) if(valueDt != DataType.FLOAT)
throw AssemblyError("float variable expected") throw AssemblyError("float variable expected")
val otherName = asmgen.asmIdentifierName(ident) val otherName = asmgen.asmVariableName(ident)
when (operator) { when (operator) {
"**" -> TODO("pow") "**" -> TODO("pow")
"+" -> TODO("+") "+" -> TODO("+")
@ -422,7 +422,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
private fun inplaceModification_byte_variable_to_memory(pointervar: IdentifierReference, operator: String, value: IdentifierReference) { private fun inplaceModification_byte_variable_to_memory(pointervar: IdentifierReference, operator: String, value: IdentifierReference) {
val otherName = asmgen.asmIdentifierName(value) val otherName = asmgen.asmVariableName(value)
when (operator) { when (operator) {
// note: ** (power) operator requires floats. // note: ** (power) operator requires floats.
"+" -> { "+" -> {
@ -680,7 +680,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
private fun inplaceModification_word_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) { private fun inplaceModification_word_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) {
val otherName = asmgen.asmIdentifierName(ident) val otherName = asmgen.asmVariableName(ident)
val valueDt = ident.targetVarDecl(program.namespace)!!.datatype val valueDt = ident.targetVarDecl(program.namespace)!!.datatype
when (valueDt) { when (valueDt) {
in ByteDatatypes -> { in ByteDatatypes -> {
@ -931,7 +931,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
private fun inplaceModification_byte_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) { private fun inplaceModification_byte_variable_to_variable(name: String, dt: DataType, operator: String, ident: IdentifierReference) {
val otherName = asmgen.asmIdentifierName(ident) val otherName = asmgen.asmVariableName(ident)
when (operator) { when (operator) {
// note: ** (power) operator requires floats. // note: ** (power) operator requires floats.
"+" -> asmgen.out(" lda $name | clc | adc $otherName | sta $name") "+" -> asmgen.out(" lda $name | clc | adc $otherName | sta $name")