Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-07-10 23:29:02 +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) {
val name = decl.name
when (decl.datatype) {
DataType.UBYTE -> out("${decl.name}\t.byte 0")
DataType.BYTE -> out("${decl.name}\t.char 0")
DataType.UWORD -> out("${decl.name}\t.word 0")
DataType.WORD -> out("${decl.name}\t.sint 0")
DataType.FLOAT -> out("${decl.name}\t.byte 0,0,0,0,0 ; float")
DataType.UBYTE -> out("$name\t.byte 0")
DataType.BYTE -> out("$name\t.char 0")
DataType.UWORD -> out("$name\t.word 0")
DataType.WORD -> out("$name\t.sint 0")
DataType.FLOAT -> out("$name\t.byte 0,0,0,0,0 ; float")
DataType.STRUCT -> {} // is flattened
DataType.STR -> {
val str = decl.value as StringLiteralValue
@ -284,9 +285,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_UB -> {
val data = makeArrayFillDataUnsigned(decl)
if (data.size <= 16)
out("${decl.name}\t.byte ${data.joinToString()}")
out("$name\t.byte ${data.joinToString()}")
else {
out(decl.name)
out(name)
for (chunk in data.chunked(16))
out(" .byte " + chunk.joinToString())
}
@ -294,9 +295,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_B -> {
val data = makeArrayFillDataSigned(decl)
if (data.size <= 16)
out("${decl.name}\t.char ${data.joinToString()}")
out("$name\t.char ${data.joinToString()}")
else {
out(decl.name)
out(name)
for (chunk in data.chunked(16))
out(" .char " + chunk.joinToString())
}
@ -304,9 +305,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_UW -> {
val data = makeArrayFillDataUnsigned(decl)
if (data.size <= 16)
out("${decl.name}\t.word ${data.joinToString()}")
out("$name\t.word ${data.joinToString()}")
else {
out(decl.name)
out(name)
for (chunk in data.chunked(16))
out(" .word " + chunk.joinToString())
}
@ -314,9 +315,9 @@ internal class AsmGen(private val program: Program,
DataType.ARRAY_W -> {
val data = makeArrayFillDataSigned(decl)
if (data.size <= 16)
out("${decl.name}\t.sint ${data.joinToString()}")
out("$name\t.sint ${data.joinToString()}")
else {
out(decl.name)
out(name)
for (chunk in data.chunked(16))
out(" .sint " + chunk.joinToString())
}
@ -334,7 +335,7 @@ internal class AsmGen(private val program: Program,
val number = (it as NumericLiteralValue).number
CompilationTarget.machine.getFloat(number).makeFloatFillAsm()
}
out(decl.name)
out(name)
for (f in array.zip(floatFills))
out(" .byte ${f.second} ; float ${f.first}")
}
@ -478,24 +479,33 @@ internal class AsmGen(private val program: Program,
return asmName
}
internal fun asmIdentifierName(identifier: IdentifierReference): String {
val name = if(identifier.memberOfStruct(program.namespace)!=null) {
identifier.targetVarDecl(program.namespace)!!.name
internal fun asmSymbolName(identifier: IdentifierReference): String {
return if(identifier.memberOfStruct(program.namespace)!=null) {
val name = identifier.targetVarDecl(program.namespace)!!.name
fixNameSymbols(name)
} 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> {
// 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 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
out(" ldy #0 | lda ($sourceName),y")
return Pair(true, sourceName)
Pair(true, sourceName)
} else {
out("""
lda $sourceName
@ -504,12 +514,12 @@ internal class AsmGen(private val program: Program,
sty P8ZP_SCRATCH_W1+1
ldy #0
lda (P8ZP_SCRATCH_W1),y""")
return Pair(false, sourceName)
Pair(false, sourceName)
}
}
fun storeByteIntoPointer(pointervar: IdentifierReference, ldaInstructionArg: String?) {
val sourceName = asmIdentifierName(pointervar)
val sourceName = asmVariableName(pointervar)
val vardecl = pointervar.targetVarDecl(program.namespace)!!
val scopedName = vardecl.makeScopedName(vardecl.name)
if(scopedName in allocatedZeropageVariables) {
@ -613,7 +623,7 @@ internal class AsmGen(private val program: Program,
if(addOneExtra) {
// add 1 to the result
if (index is IdentifierReference) {
val indexName = asmIdentifierName(index)
val indexName = asmVariableName(index)
when(elementDt) {
in ByteDatatypes -> {
out(" ldy $indexName | iny")
@ -663,7 +673,7 @@ internal class AsmGen(private val program: Program,
}
} else {
if (index is IdentifierReference) {
val indexName = asmIdentifierName(index)
val indexName = asmVariableName(index)
when(elementDt) {
in ByteDatatypes -> out(" ld$reg $indexName")
in WordDatatypes -> {
@ -817,7 +827,7 @@ internal class AsmGen(private val program: Program,
}
is IdentifierReference -> {
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) {
DataType.UBYTE, DataType.BYTE -> {
out(" lda $name")
@ -1088,7 +1098,7 @@ $counterVar .byte 0""")
return when {
jmp.identifier!=null -> {
val target = jmp.identifier.targetStatement(program.namespace)
val asmName = asmIdentifierName(jmp.identifier)
val asmName = asmSymbolName(jmp.identifier)
if(target is Label)
"_$asmName" // prefix with underscore to jump to local label
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()
if (variable is IdentifierReference) {
val decl = variable.targetVarDecl(program.namespace)!!
val varName = asmgen.asmIdentifierName(variable)
val varName = asmgen.asmVariableName(variable)
val numElements = decl.arraysize!!.constIndex()
when (decl.datatype) {
DataType.ARRAY_UB, DataType.ARRAY_B -> {
@ -114,7 +114,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
val variable = fcall.args.single()
if (variable is IdentifierReference) {
val decl = variable.targetVarDecl(program.namespace)!!
val varName = asmgen.asmIdentifierName(variable)
val varName = asmgen.asmVariableName(variable)
val numElements = decl.arraysize!!.constIndex()
when (decl.datatype) {
DataType.ARRAY_UB, DataType.ARRAY_B -> {
@ -167,7 +167,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
}
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" lda $variable | lsr a | bcc + | ora #\$80 |+ | sta $variable")
}
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")
}
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 |+ ")
}
else -> throw AssemblyError("weird type")
@ -219,7 +219,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
}
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" ror $variable")
}
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")
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" ror $variable+1 | ror $variable")
}
else -> throw AssemblyError("weird type")
@ -264,7 +264,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
}
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" lda $variable | cmp #\$80 | rol a | sta $variable")
}
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")
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" asl $variable | rol $variable+1 | bcc + | inc $variable |+ ")
}
else -> throw AssemblyError("weird type")
@ -316,7 +316,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
}
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" rol $variable")
}
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")
}
is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what)
val variable = asmgen.asmVariableName(what)
asmgen.out(" rol $variable | rol $variable+1")
}
else -> throw AssemblyError("weird type")
@ -383,7 +383,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
}
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("""
lda #<$name
ldy #>$name
@ -396,8 +396,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
val first = fcall.args[0]
val second = fcall.args[1]
if(first is IdentifierReference && second is IdentifierReference) {
val firstName = asmgen.asmIdentifierName(first)
val secondName = asmgen.asmIdentifierName(second)
val firstName = asmgen.asmVariableName(first)
val secondName = asmgen.asmVariableName(second)
val dt = first.inferType(program)
if(dt.istype(DataType.BYTE) || dt.istype(DataType.UBYTE)) {
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)
throw AssemblyError("msb(const) should have been const-folded away")
if (arg is IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(arg)
val sourceName = asmgen.asmVariableName(arg)
asmgen.out(" lda $sourceName+1 | sta P8ESTACK_LO,x | dex")
} else {
asmgen.translateExpression(arg)
@ -476,7 +476,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
if (arg is NumericLiteralValue)
throw AssemblyError("lsb(const) should have been const-folded away")
if (arg is IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(arg)
val sourceName = asmgen.asmVariableName(arg)
asmgen.out(" lda $sourceName | sta P8ESTACK_LO,x | dex")
} else {
asmgen.translateExpression(arg)
@ -486,7 +486,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
private fun outputPushAddressAndLenghtOfArray(arg: Expression) {
arg as IdentifierReference
val identifierName = asmgen.asmIdentifierName(arg)
val identifierName = asmgen.asmVariableName(arg)
val size = arg.targetVarDecl(program.namespace)!!.arraysize!!.constIndex()!!
asmgen.out("""
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) {
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")
}
@ -169,7 +169,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
}
private fun translateExpression(expr: IdentifierReference) {
val varname = asmgen.asmIdentifierName(expr)
val varname = asmgen.asmVariableName(expr)
when(expr.inferType(program).typeOrElse(DataType.STRUCT)) {
DataType.UBYTE, DataType.BYTE -> {
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) {
val index = arrayExpr.arrayspec.index
val elementDt = arrayExpr.inferType(program).typeOrElse(DataType.STRUCT)
val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier)
val arrayVarName = asmgen.asmVariableName(arrayExpr.identifier)
if(index is NumericLiteralValue) {
val indexValue = index.number.toInt() * elementDt.memorySize()
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"
// 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.from)
asmgen.out("""
@ -74,7 +74,7 @@ $endLabel inx""")
// bytes, step >= 2 or <= -2
// 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.from)
asmgen.out("""
@ -115,7 +115,7 @@ $endLabel inx""")
stepsize == 1 || stepsize == -1 -> {
asmgen.translateExpression(range.to)
assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda P8ESTACK_HI+1,x
sta $modifiedLabel+1
@ -159,7 +159,7 @@ $modifiedLabel2 cmp #0 ; modified
sta $modifiedLabel2+1
""")
assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(loopLabel)
asmgen.translate(stmt.body)
@ -210,7 +210,7 @@ $endLabel inx""")
sta $modifiedLabel2+1
""")
assignLoopvar(stmt, range)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out(loopLabel)
asmgen.translate(stmt.body)
@ -269,7 +269,7 @@ $endLabel inx""")
val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel)
val iterableName = asmgen.asmIdentifierName(ident)
val iterableName = asmgen.asmVariableName(ident)
val decl = ident.targetVarDecl(program.namespace)!!
when(iterableDt) {
DataType.STR -> {
@ -280,7 +280,7 @@ $endLabel inx""")
sty $loopLabel+2
$loopLabel lda ${65535.toHex()} ; modified
beq $endLabel
sta ${asmgen.asmIdentifierName(stmt.loopVar)}""")
sta ${asmgen.asmVariableName(stmt.loopVar)}""")
asmgen.translate(stmt.body)
asmgen.out("""
inc $loopLabel+1
@ -296,7 +296,7 @@ $endLabel""")
ldy #0
$loopLabel sty $indexVar
lda $iterableName,y
sta ${asmgen.asmIdentifierName(stmt.loopVar)}""")
sta ${asmgen.asmVariableName(stmt.loopVar)}""")
asmgen.translate(stmt.body)
if(length<=255) {
asmgen.out("""
@ -326,7 +326,7 @@ $indexVar .byte 0""")
DataType.ARRAY_W, DataType.ARRAY_UW -> {
val length = decl.arraysize!!.constIndex()!! * 2
val indexVar = asmgen.makeLabel("for_index")
val loopvarName = asmgen.asmIdentifierName(stmt.loopVar)
val loopvarName = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
ldy #0
$loopLabel sty $indexVar
@ -389,7 +389,7 @@ $indexVar .byte 0""")
when(iterableDt) {
DataType.ARRAY_B, DataType.ARRAY_UB -> {
// loop over byte range via loopvar, step >= 2 or <= -2
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda #${range.first}
sta $varname
@ -454,7 +454,7 @@ $loopLabel""")
}
DataType.ARRAY_W, DataType.ARRAY_UW -> {
// 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) {
0, 1, -1 -> {
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 endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda #${range.first}
sta $varname
@ -525,7 +525,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda #${range.first}
sta $varname
@ -563,7 +563,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda #<${range.first}
ldy #>${range.first}
@ -591,7 +591,7 @@ $endLabel""")
val loopLabel = asmgen.makeLabel("for_loop")
val endLabel = asmgen.makeLabel("for_end")
asmgen.loopEndLabels.push(endLabel)
val varname = asmgen.asmIdentifierName(stmt.loopVar)
val varname = asmgen.asmVariableName(stmt.loopVar)
asmgen.out("""
lda #<${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)
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(sub.asmParameterRegisters.isEmpty()) {
// via variables
@ -139,7 +139,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
asmgen.out(if(carrySet) " sec" else " clc")
}
is IdentifierReference -> {
val sourceName = asmgen.asmIdentifierName(value)
val sourceName = asmgen.asmVariableName(value)
asmgen.out("""
pha
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
when {
targetIdent!=null -> {
val what = asmgen.asmIdentifierName(targetIdent)
val what = asmgen.asmVariableName(targetIdent)
when (stmt.target.inferType(program, stmt).typeOrElse(DataType.STRUCT)) {
in ByteDatatypes -> asmgen.out(if (incr) " inc $what" else " dec $what")
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")
}
is IdentifierReference -> {
val what = asmgen.asmIdentifierName(addressExpr)
val what = asmgen.asmVariableName(addressExpr)
asmgen.out(" lda $what | sta (+) +1 | lda $what+1 | sta (+) +2")
if(incr)
asmgen.out("+\tinc ${'$'}ffff\t; modified")
@ -70,7 +70,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
}
targetArrayIdx!=null -> {
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)
when(index) {
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 asmVarname by lazy {
if(variable!=null)
asmgen.asmIdentifierName(variable)
asmgen.asmVariableName(variable)
else
asmgen.asmIdentifierName(array!!.identifier)
asmgen.asmVariableName(array!!.identifier)
}
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 elementDt = assign.source.datatype
val index = value.arrayspec.index
val arrayVarName = asmgen.asmIdentifierName(value.identifier)
val arrayVarName = asmgen.asmVariableName(value.identifier)
if (index is NumericLiteralValue) {
// constant array index value
val indexValue = index.number.toInt() * elementDt.memorySize()
@ -316,7 +316,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
}
TargetStorageKind.STACK -> {
val srcname = asmgen.asmIdentifierName(name)
val srcname = asmgen.asmVariableName(name)
asmgen.out("""
lda #<$srcname
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) {
val sourceName = asmgen.asmIdentifierName(variable)
val sourceName = asmgen.asmVariableName(variable)
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
@ -432,7 +432,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun assignVariableFloat(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable)
val sourceName = asmgen.asmVariableName(variable)
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
@ -467,7 +467,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun assignVariableByte(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable)
val sourceName = asmgen.asmVariableName(variable)
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
@ -542,7 +542,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
CpuRegister.X -> asmgen.out(" txa")
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 -> {
asmgen.saveRegister(register)
@ -852,7 +852,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" sta ${target.asmVarname}")
}
TargetStorageKind.MEMORY -> {
val sourceName = asmgen.asmIdentifierName(identifier)
val sourceName = asmgen.asmVariableName(identifier)
storeByteViaRegisterAInMemoryAddress(sourceName, target.memory!!)
}
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)
throw AssemblyError("float variable expected")
val otherName = asmgen.asmIdentifierName(ident)
val otherName = asmgen.asmVariableName(ident)
when (operator) {
"**" -> TODO("pow")
"+" -> 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) {
val otherName = asmgen.asmIdentifierName(value)
val otherName = asmgen.asmVariableName(value)
when (operator) {
// 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) {
val otherName = asmgen.asmIdentifierName(ident)
val otherName = asmgen.asmVariableName(ident)
val valueDt = ident.targetVarDecl(program.namespace)!!.datatype
when (valueDt) {
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) {
val otherName = asmgen.asmIdentifierName(ident)
val otherName = asmgen.asmVariableName(ident)
when (operator) {
// note: ** (power) operator requires floats.
"+" -> asmgen.out(" lda $name | clc | adc $otherName | sta $name")