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

reducing dependencies

Browse Source
This commit is contained in:
Irmen de Jong 2021-02-09 19:03:21 +01:00
parent 628390c3b5
commit 3502f65332
8 changed files with 61 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt
View File

@ -2,13 +2,12 @@ package prog8.compiler.target.c64
import prog8.compiler.CompilationOptions import prog8.compiler.CompilationOptions
import prog8.compiler.OutputType import prog8.compiler.OutputType
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.IAssemblyProgram import prog8.compiler.target.IAssemblyProgram
import prog8.compiler.target.generatedLabelPrefix import prog8.compiler.target.generatedLabelPrefix
import java.nio.file.Path import java.nio.file.Path
import kotlin.system.exitProcess import kotlin.system.exitProcess
class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyProgram { class AssemblyProgram(override val name: String, outputDir: Path, private val compTarget: String) : IAssemblyProgram {
private val assemblyFile = outputDir.resolve("$name.asm") private val assemblyFile = outputDir.resolve("$name.asm")
private val prgFile = outputDir.resolve("$name.prg") private val prgFile = outputDir.resolve("$name.prg")
private val binFile = outputDir.resolve("$name.bin") private val binFile = outputDir.resolve("$name.bin")
@ -23,12 +22,12 @@ class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyPro
val outFile = when (options.output) { val outFile = when (options.output) {
OutputType.PRG -> { OutputType.PRG -> {
command.add("--cbm-prg") command.add("--cbm-prg")
println("\nCreating prg for target ${ICompilationTarget.instance.name}.") println("\nCreating prg for target $compTarget.")
prgFile prgFile
} }
OutputType.RAW -> { OutputType.RAW -> {
command.add("--nostart") command.add("--nostart")
println("\nCreating raw binary for target ${ICompilationTarget.instance.name}.") println("\nCreating raw binary for target $compTarget.")
binFile binFile
} }
} }

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

@ -25,7 +25,7 @@ internal class AsmGen(private val program: Program,
val errors: ErrorReporter, val errors: ErrorReporter,
val zeropage: Zeropage, val zeropage: Zeropage,
val options: CompilationOptions, val options: CompilationOptions,
private val compTarget: ICompilationTarget, val compTarget: ICompilationTarget,
private val outputDir: Path): IAssemblyGenerator { private val outputDir: Path): IAssemblyGenerator {
// for expressions and augmented assignments: // for expressions and augmented assignments:
@ -40,7 +40,7 @@ internal class AsmGen(private val program: Program,
private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this) private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
private val functioncallAsmGen = FunctionCallAsmGen(program, this) private val functioncallAsmGen = FunctionCallAsmGen(program, this)
private val expressionsAsmGen = ExpressionsAsmGen(program, this) private val expressionsAsmGen = ExpressionsAsmGen(program, this)
private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen, compTarget) private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen)
private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen) private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen)
internal val loopEndLabels = ArrayDeque<String>() internal val loopEndLabels = ArrayDeque<String>()
private val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>() private val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
@ -85,7 +85,7 @@ internal class AsmGen(private val program: Program,
} }
} }
return AssemblyProgram(program.name, outputDir) return AssemblyProgram(program.name, outputDir, compTarget.name)
} }

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

@ -9,7 +9,6 @@ import prog8.ast.statements.*
import prog8.ast.toHex import prog8.ast.toHex
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.functions.FSignature import prog8.compiler.functions.FSignature
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.c64.codegen.assignment.* import prog8.compiler.target.c64.codegen.assignment.*
import prog8.compiler.target.subroutineFloatEvalResultVar2 import prog8.compiler.target.subroutineFloatEvalResultVar2
@ -679,8 +678,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexValue2: NumericLiteralValue) { private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexValue2: NumericLiteralValue) {
val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) val index1 = indexValue1.number.toInt() * asmgen.compTarget.memorySize(elementDt)
val index2 = indexValue2.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) val index2 = indexValue2.number.toInt() * asmgen.compTarget.memorySize(elementDt)
when(elementDt) { when(elementDt) {
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
asmgen.out(""" asmgen.out("""
@ -793,7 +792,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexName2: IdentifierReference) { private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexName2: IdentifierReference) {
val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) val index1 = indexValue1.number.toInt() * asmgen.compTarget.memorySize(elementDt)
val idxAsmName2 = asmgen.asmVariableName(indexName2) val idxAsmName2 = asmgen.asmVariableName(indexName2)
when(elementDt) { when(elementDt) {
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
@ -852,7 +851,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexValue2: NumericLiteralValue) { private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexValue2: NumericLiteralValue) {
val idxAsmName1 = asmgen.asmVariableName(indexName1) val idxAsmName1 = asmgen.asmVariableName(indexName1)
val index2 = indexValue2.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) val index2 = indexValue2.number.toInt() * asmgen.compTarget.memorySize(elementDt)
when(elementDt) { when(elementDt) {
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
asmgen.out(""" asmgen.out("""

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

@ -9,7 +9,6 @@ import prog8.ast.statements.Subroutine
import prog8.ast.toHex import prog8.ast.toHex
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.functions.BuiltinFunctions import prog8.compiler.functions.BuiltinFunctions
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.CpuType import prog8.compiler.target.CpuType
import prog8.compiler.target.subroutineFloatEvalResultVar1 import prog8.compiler.target.subroutineFloatEvalResultVar1
import kotlin.math.absoluteValue import kotlin.math.absoluteValue
@ -1394,7 +1393,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
when(typecast.type) { when(typecast.type) {
DataType.UBYTE, DataType.BYTE -> {} DataType.UBYTE, DataType.BYTE -> {}
DataType.UWORD, DataType.WORD -> { DataType.UWORD, DataType.WORD -> {
if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_HI+1,x") asmgen.out(" stz P8ESTACK_HI+1,x")
else else
asmgen.out(" lda #0 | sta P8ESTACK_HI+1,x") asmgen.out(" lda #0 | sta P8ESTACK_HI+1,x")
@ -1460,7 +1459,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
fun assignViaExprEval() { fun assignViaExprEval() {
asmgen.assignExpressionToVariable(expr.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null) asmgen.assignExpressionToVariable(expr.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) { if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02) {
if (pushResultOnEstack) { if (pushResultOnEstack) {
asmgen.out(" lda (P8ZP_SCRATCH_W2) | dex | sta P8ESTACK_LO+1,x") asmgen.out(" lda (P8ZP_SCRATCH_W2) | dex | sta P8ESTACK_LO+1,x")
} else { } else {
@ -1674,7 +1673,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
} }
DataType.UWORD -> { DataType.UWORD -> {
if(amount>=16) { if(amount>=16) {
if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_LO+1,x | stz P8ESTACK_HI+1,x") asmgen.out(" stz P8ESTACK_LO+1,x | stz P8ESTACK_HI+1,x")
else else
asmgen.out(" lda #0 | sta P8ESTACK_LO+1,x | sta P8ESTACK_HI+1,x") asmgen.out(" lda #0 | sta P8ESTACK_LO+1,x | sta P8ESTACK_HI+1,x")
@ -1889,7 +1888,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
val elementDt = elementIDt.typeOrElse(DataType.STRUCT) val elementDt = elementIDt.typeOrElse(DataType.STRUCT)
val arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar) val arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar)
if(arrayExpr.indexer.indexNum!=null) { if(arrayExpr.indexer.indexNum!=null) {
val indexValue = arrayExpr.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt) val indexValue = arrayExpr.indexer.constIndex()!! * asmgen.compTarget.memorySize(elementDt)
when(elementDt) { when(elementDt) {
in ByteDatatypes -> { in ByteDatatypes -> {
asmgen.out(" lda $arrayVarName+$indexValue | sta P8ESTACK_LO,x | dex") asmgen.out(" lda $arrayVarName+$indexValue | sta P8ESTACK_LO,x | dex")

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

@ -7,7 +7,6 @@ import prog8.ast.base.*
import prog8.ast.expressions.* import prog8.ast.expressions.*
import prog8.ast.statements.* import prog8.ast.statements.*
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.CpuType import prog8.compiler.target.CpuType
import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
@ -169,7 +168,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
lda P8ESTACK_LO$plusIdxStr,x lda P8ESTACK_LO$plusIdxStr,x
sta cx16.${argi.value.second.registerOrPair.toString().toLowerCase()} sta cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}
""") """)
if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1") asmgen.out(" stz cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")
else else
asmgen.out(" lda #0 | sta cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1") asmgen.out(" lda #0 | sta cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")

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

@ -7,7 +7,6 @@ import prog8.ast.expressions.NumericLiteralValue
import prog8.ast.statements.PostIncrDecr import prog8.ast.statements.PostIncrDecr
import prog8.ast.toHex import prog8.ast.toHex
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.target.ICompilationTarget
internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) { internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {
@ -68,7 +67,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.arrayvar) val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.arrayvar)
val elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT) val elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT)
if(targetArrayIdx.indexer.indexNum!=null) { if(targetArrayIdx.indexer.indexNum!=null) {
val indexValue = targetArrayIdx.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt) val indexValue = targetArrayIdx.indexer.constIndex()!! * asmgen.compTarget.memorySize(elementDt)
when(elementDt) { when(elementDt) {
in ByteDatatypes -> asmgen.out(if (incr) " inc $asmArrayvarname+$indexValue" else " dec $asmArrayvarname+$indexValue") in ByteDatatypes -> asmgen.out(if (incr) " inc $asmArrayvarname+$indexValue" else " dec $asmArrayvarname+$indexValue")
in WordDatatypes -> { in WordDatatypes -> {

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

@ -9,13 +9,12 @@ import prog8.compiler.AssemblyError
import prog8.compiler.functions.BuiltinFunctions import prog8.compiler.functions.BuiltinFunctions
import prog8.compiler.functions.builtinFunctionReturnType import prog8.compiler.functions.builtinFunctionReturnType
import prog8.compiler.target.CpuType import prog8.compiler.target.CpuType
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.c64.codegen.AsmGen import prog8.compiler.target.c64.codegen.AsmGen
import prog8.compiler.target.c64.codegen.ExpressionsAsmGen import prog8.compiler.target.c64.codegen.ExpressionsAsmGen
internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen, internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen,
private val exprAsmgen: ExpressionsAsmGen, private val compTarget: ICompilationTarget) { private val exprAsmgen: ExpressionsAsmGen) {
private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, exprAsmgen, asmgen) private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, exprAsmgen, asmgen)
@ -67,7 +66,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val arrayVarName = asmgen.asmVariableName(value.arrayvar) val arrayVarName = asmgen.asmVariableName(value.arrayvar)
if (value.indexer.indexNum!=null) { if (value.indexer.indexNum!=null) {
// constant array index value // constant array index value
val indexValue = value.indexer.constIndex()!! * compTarget.memorySize(elementDt) val indexValue = value.indexer.constIndex()!! * asmgen.compTarget.memorySize(elementDt)
when (elementDt) { when (elementDt) {
in ByteDatatypes -> { in ByteDatatypes -> {
asmgen.out(" lda $arrayVarName+$indexValue") asmgen.out(" lda $arrayVarName+$indexValue")
@ -115,7 +114,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
SourceStorageKind.MEMORY -> { SourceStorageKind.MEMORY -> {
fun assignViaExprEval(expression: Expression) { fun assignViaExprEval(expression: Expression) {
assignExpressionToVariable(expression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope) assignExpressionToVariable(expression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
if (compTarget.machine.cpu == CpuType.CPU65c02) if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" lda (P8ZP_SCRATCH_W2)") asmgen.out(" lda (P8ZP_SCRATCH_W2)")
else else
asmgen.out(" ldy #0 | lda (P8ZP_SCRATCH_W2),y") asmgen.out(" ldy #0 | lda (P8ZP_SCRATCH_W2),y")
@ -320,7 +319,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
fun assignViaExprEval(addressExpression: Expression) { fun assignViaExprEval(addressExpression: Expression) {
asmgen.assignExpressionToVariable(addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null) asmgen.assignExpressionToVariable(addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
if (compTarget.machine.cpu == CpuType.CPU65c02) if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" lda (P8ZP_SCRATCH_W2)") asmgen.out(" lda (P8ZP_SCRATCH_W2)")
else else
asmgen.out(" ldy #0 | lda (P8ZP_SCRATCH_W2),y") asmgen.out(" ldy #0 | lda (P8ZP_SCRATCH_W2),y")
@ -474,7 +473,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName")
} }
DataType.UWORD, DataType.WORD -> { DataType.UWORD, DataType.WORD -> {
if(compTarget.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | stz $targetAsmVarName+1") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | stz $targetAsmVarName+1")
else else
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | lda #0 | sta $targetAsmVarName+1") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | lda #0 | sta $targetAsmVarName+1")
@ -497,7 +496,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName")
} }
DataType.UWORD -> { DataType.UWORD -> {
if(compTarget.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | stz $targetAsmVarName+1") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | stz $targetAsmVarName+1")
else else
asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | lda #0 | sta $targetAsmVarName+1") asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | lda #0 | sta $targetAsmVarName+1")
@ -593,7 +592,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName")
} }
DataType.UWORD, DataType.WORD -> { DataType.UWORD, DataType.WORD -> {
if(compTarget.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | stz $targetAsmVarName+1") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | stz $targetAsmVarName+1")
else else
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | lda #0 | sta $targetAsmVarName+1") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | lda #0 | sta $targetAsmVarName+1")
@ -621,7 +620,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName")
} }
DataType.UWORD -> { DataType.UWORD -> {
if(compTarget.machine.cpu==CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02)
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | stz $targetAsmVarName+1") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | stz $targetAsmVarName+1")
else else
asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | lda #0 | sta $targetAsmVarName+1") asmgen.out(" st${regs.toString().toLowerCase()} $targetAsmVarName | lda #0 | sta $targetAsmVarName+1")
@ -763,7 +762,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {
if(target.constArrayIndexValue!=null) { if(target.constArrayIndexValue!=null) {
val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype) val scaledIdx = target.constArrayIndexValue!! * asmgen.compTarget.memorySize(target.datatype)
when(target.datatype) { when(target.datatype) {
in ByteDatatypes -> { in ByteDatatypes -> {
asmgen.out(" inx | lda P8ESTACK_LO,x | sta ${target.asmVarname}+$scaledIdx") asmgen.out(" inx | lda P8ESTACK_LO,x | sta ${target.asmVarname}+$scaledIdx")
@ -969,7 +968,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {
target.array!! target.array!!
if(target.constArrayIndexValue!=null) { if(target.constArrayIndexValue!=null) {
val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype) val scaledIdx = target.constArrayIndexValue!! * asmgen.compTarget.memorySize(target.datatype)
when(target.datatype) { when(target.datatype) {
in ByteDatatypes -> { in ByteDatatypes -> {
asmgen.out(" lda $sourceName | sta ${target.asmVarname}+$scaledIdx") asmgen.out(" lda $sourceName | sta ${target.asmVarname}+$scaledIdx")
@ -1192,7 +1191,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {
if (target.constArrayIndexValue!=null) { if (target.constArrayIndexValue!=null) {
val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype) val scaledIdx = target.constArrayIndexValue!! * asmgen.compTarget.memorySize(target.datatype)
asmgen.out(" lda $sourceName | sta ${target.asmVarname}+$scaledIdx") asmgen.out(" lda $sourceName | sta ${target.asmVarname}+$scaledIdx")
} }
else { else {
@ -1296,7 +1295,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
when(wordtarget.kind) { when(wordtarget.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.out(" lda $sourceName | sta ${wordtarget.asmVarname}") asmgen.out(" lda $sourceName | sta ${wordtarget.asmVarname}")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz ${wordtarget.asmVarname}+1") asmgen.out(" stz ${wordtarget.asmVarname}+1")
else else
asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1") asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1")
@ -1305,7 +1304,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
if (wordtarget.constArrayIndexValue!=null) { if (wordtarget.constArrayIndexValue!=null) {
val scaledIdx = wordtarget.constArrayIndexValue!! * 2 val scaledIdx = wordtarget.constArrayIndexValue!! * 2
asmgen.out(" lda $sourceName | sta ${wordtarget.asmVarname}+$scaledIdx") asmgen.out(" lda $sourceName | sta ${wordtarget.asmVarname}+$scaledIdx")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz ${wordtarget.asmVarname}+$scaledIdx+1") asmgen.out(" stz ${wordtarget.asmVarname}+$scaledIdx+1")
else else
asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+$scaledIdx+1") asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+$scaledIdx+1")
@ -1330,7 +1329,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
TargetStorageKind.STACK -> { TargetStorageKind.STACK -> {
asmgen.out(" lda $sourceName | sta P8ESTACK_LO,x") asmgen.out(" lda $sourceName | sta P8ESTACK_LO,x")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_HI,x | dex") asmgen.out(" stz P8ESTACK_HI,x | dex")
else else
asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex") asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex")
@ -1572,7 +1571,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
private fun assignConstantWord(target: AsmAssignTarget, word: Int) { private fun assignConstantWord(target: AsmAssignTarget, word: Int) {
if(word==0 && compTarget.machine.cpu == CpuType.CPU65c02) { if(word==0 && asmgen.compTarget.machine.cpu == CpuType.CPU65c02) {
// optimize setting zero value for this processor // optimize setting zero value for this processor
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
@ -1667,7 +1666,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
private fun assignConstantByte(target: AsmAssignTarget, byte: Short) { private fun assignConstantByte(target: AsmAssignTarget, byte: Short) {
if(byte==0.toShort() && compTarget.machine.cpu == CpuType.CPU65c02) { if(byte==0.toShort() && asmgen.compTarget.machine.cpu == CpuType.CPU65c02) {
// optimize setting zero value for this cpu // optimize setting zero value for this cpu
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
@ -1737,7 +1736,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float") RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
in Cx16VirtualRegisters -> { in Cx16VirtualRegisters -> {
asmgen.out(" lda #${byte.toHex()} | sta cx16.${target.register.toString().toLowerCase()}") asmgen.out(" lda #${byte.toHex()} | sta cx16.${target.register.toString().toLowerCase()}")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz cx16.${target.register.toString().toLowerCase()}+1\n") asmgen.out(" stz cx16.${target.register.toString().toLowerCase()}+1\n")
else else
asmgen.out(" lda #0 | sta cx16.${target.register.toString().toLowerCase()}+1\n") asmgen.out(" lda #0 | sta cx16.${target.register.toString().toLowerCase()}+1\n")
@ -1758,7 +1757,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
// optimized case for float zero // optimized case for float zero
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(""" asmgen.out("""
stz ${target.asmVarname} stz ${target.asmVarname}
stz ${target.asmVarname}+1 stz ${target.asmVarname}+1
@ -1778,8 +1777,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {
if (target.array!!.indexer.indexNum!=null) { if (target.array!!.indexer.indexNum!=null) {
val indexValue = target.array.indexer.constIndex()!! * compTarget.memorySize(DataType.FLOAT) val indexValue = target.array.indexer.constIndex()!! * asmgen.compTarget.memorySize(DataType.FLOAT)
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(""" asmgen.out("""
stz ${target.asmVarname}+$indexValue stz ${target.asmVarname}+$indexValue
stz ${target.asmVarname}+$indexValue+1 stz ${target.asmVarname}+$indexValue+1
@ -1843,7 +1842,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
TargetStorageKind.ARRAY -> { TargetStorageKind.ARRAY -> {
val arrayVarName = target.asmVarname val arrayVarName = target.asmVarname
if (target.array!!.indexer.indexNum!=null) { if (target.array!!.indexer.indexNum!=null) {
val indexValue = target.array.indexer.constIndex()!! * compTarget.memorySize(DataType.FLOAT) val indexValue = target.array.indexer.constIndex()!! * asmgen.compTarget.memorySize(DataType.FLOAT)
asmgen.out(""" asmgen.out("""
lda $constFloat lda $constFloat
sta $arrayVarName+$indexValue sta $arrayVarName+$indexValue
@ -1976,7 +1975,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
when(wordtarget.kind) { when(wordtarget.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.out(" lda ${address.toHex()} | sta ${wordtarget.asmVarname}") asmgen.out(" lda ${address.toHex()} | sta ${wordtarget.asmVarname}")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz ${wordtarget.asmVarname}+1") asmgen.out(" stz ${wordtarget.asmVarname}+1")
else else
asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1") asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1")
@ -1992,7 +1991,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} }
TargetStorageKind.STACK -> { TargetStorageKind.STACK -> {
asmgen.out(" lda ${address.toHex()} | sta P8ESTACK_LO,x") asmgen.out(" lda ${address.toHex()} | sta P8ESTACK_LO,x")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_HI,x | dex") asmgen.out(" stz P8ESTACK_HI,x | dex")
else else
asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex") asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex")
@ -2004,7 +2003,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
asmgen.loadByteFromPointerIntoA(identifier) asmgen.loadByteFromPointerIntoA(identifier)
asmgen.out(" sta ${wordtarget.asmVarname}") asmgen.out(" sta ${wordtarget.asmVarname}")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz ${wordtarget.asmVarname}+1") asmgen.out(" stz ${wordtarget.asmVarname}+1")
else else
asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1") asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1")
@ -2024,7 +2023,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
TargetStorageKind.STACK -> { TargetStorageKind.STACK -> {
asmgen.loadByteFromPointerIntoA(identifier) asmgen.loadByteFromPointerIntoA(identifier)
asmgen.out(" sta P8ESTACK_LO,x") asmgen.out(" sta P8ESTACK_LO,x")
if(compTarget.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_HI,x | dex") asmgen.out(" stz P8ESTACK_HI,x | dex")
else else
asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex") asmgen.out(" lda #0 | sta P8ESTACK_HI,x | dex")
@ -2042,7 +2041,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
when(addressExpr) { when(addressExpr) {
is NumericLiteralValue, is IdentifierReference -> { is NumericLiteralValue, is IdentifierReference -> {
assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null) assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
if (compTarget.machine.cpu == CpuType.CPU65c02) if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" sta (P8ZP_SCRATCH_W2)") asmgen.out(" sta (P8ZP_SCRATCH_W2)")
else else
asmgen.out(" ldy #0 | sta (P8ZP_SCRATCH_W2),y") asmgen.out(" ldy #0 | sta (P8ZP_SCRATCH_W2),y")
@ -2052,7 +2051,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" pha") asmgen.out(" pha")
assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null) assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
asmgen.out(" pla") asmgen.out(" pla")
if (compTarget.machine.cpu == CpuType.CPU65c02) if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" sta (P8ZP_SCRATCH_W2)") asmgen.out(" sta (P8ZP_SCRATCH_W2)")
else else
asmgen.out(" ldy #0 | sta (P8ZP_SCRATCH_W2),y") asmgen.out(" ldy #0 | sta (P8ZP_SCRATCH_W2),y")
@ -2064,7 +2063,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val sourceName = asmgen.asmVariableName(pointervar) val sourceName = asmgen.asmVariableName(pointervar)
val vardecl = pointervar.targetVarDecl(program)!! val vardecl = pointervar.targetVarDecl(program)!!
val scopedName = vardecl.makeScopedName(vardecl.name) val scopedName = vardecl.makeScopedName(vardecl.name)
if (compTarget.machine.cpu == CpuType.CPU65c02) { if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02) {
if (asmgen.isZpVar(scopedName)) { if (asmgen.isZpVar(scopedName)) {
// pointervar is already in the zero page, no need to copy // pointervar is already in the zero page, no need to copy
asmgen.out(" sta ($sourceName)") asmgen.out(" sta ($sourceName)")

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

@ -6,7 +6,6 @@ import prog8.ast.expressions.*
import prog8.ast.statements.Subroutine import prog8.ast.statements.Subroutine
import prog8.ast.toHex import prog8.ast.toHex
import prog8.compiler.AssemblyError import prog8.compiler.AssemblyError
import prog8.compiler.target.ICompilationTarget
import prog8.compiler.target.CpuType import prog8.compiler.target.CpuType
import prog8.compiler.target.Cx16Target import prog8.compiler.target.Cx16Target
import prog8.compiler.target.c64.codegen.AsmGen import prog8.compiler.target.c64.codegen.AsmGen
@ -202,7 +201,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
with(target.array!!.indexer) { with(target.array!!.indexer) {
when { when {
indexNum!=null -> { indexNum!=null -> {
val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*ICompilationTarget.instance.memorySize(target.datatype)}" val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*asmgen.compTarget.memorySize(target.datatype)}"
when(target.datatype) { when(target.datatype) {
in ByteDatatypes -> { in ByteDatatypes -> {
when { when {
@ -632,7 +631,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
"<<" -> { "<<" -> {
if(value>=8) { if(value>=8) {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name") asmgen.out(" stz $name")
else else
asmgen.out(" lda #0 | sta $name") asmgen.out(" lda #0 | sta $name")
@ -643,7 +642,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
if(value>0) { if(value>0) {
if (dt == DataType.UBYTE) { if (dt == DataType.UBYTE) {
if(value>=8) { if(value>=8) {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name") asmgen.out(" stz $name")
else else
asmgen.out(" lda #0 | sta $name") asmgen.out(" lda #0 | sta $name")
@ -858,14 +857,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
"<<" -> { "<<" -> {
when { when {
value>=16 -> { value>=16 -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name | stz $name+1") asmgen.out(" stz $name | stz $name+1")
else else
asmgen.out(" lda #0 | sta $name | sta $name+1") asmgen.out(" lda #0 | sta $name | sta $name+1")
} }
value==8 -> { value==8 -> {
asmgen.out(" lda $name | sta $name+1") asmgen.out(" lda $name | sta $name+1")
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name") asmgen.out(" stz $name")
else else
asmgen.out(" lda #0 | sta $name") asmgen.out(" lda #0 | sta $name")
@ -885,14 +884,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
if(dt==DataType.UWORD) { if(dt==DataType.UWORD) {
when { when {
value>=16 -> { value>=16 -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name | stz $name+1") asmgen.out(" stz $name | stz $name+1")
else else
asmgen.out(" lda #0 | sta $name | sta $name+1") asmgen.out(" lda #0 | sta $name | sta $name+1")
} }
value==8 -> { value==8 -> {
asmgen.out(" lda $name+1 | sta $name") asmgen.out(" lda $name+1 | sta $name")
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name+1") asmgen.out(" stz $name+1")
else else
asmgen.out(" lda #0 | sta $name+1") asmgen.out(" lda #0 | sta $name+1")
@ -941,13 +940,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
"&", "and" -> { "&", "and" -> {
when { when {
value == 0 -> { value == 0 -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name | stz $name+1") asmgen.out(" stz $name | stz $name+1")
else else
asmgen.out(" lda #0 | sta $name | sta $name+1") asmgen.out(" lda #0 | sta $name | sta $name+1")
} }
value and 255 == 0 -> { value and 255 == 0 -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name") asmgen.out(" stz $name")
else else
asmgen.out(" lda #0 | sta $name") asmgen.out(" lda #0 | sta $name")
@ -955,7 +954,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
value < 0x0100 -> { value < 0x0100 -> {
asmgen.out(" lda $name | and #$value | sta $name") asmgen.out(" lda $name | and #$value | sta $name")
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name+1") asmgen.out(" stz $name+1")
else else
asmgen.out(" lda #0 | sta $name+1") asmgen.out(" lda #0 | sta $name+1")
@ -1042,7 +1041,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
} }
"*" -> { "*" -> {
asmgen.out(" lda $otherName | sta P8ZP_SCRATCH_W1") asmgen.out(" lda $otherName | sta P8ZP_SCRATCH_W1")
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz P8ZP_SCRATCH_W1+1") asmgen.out(" stz P8ZP_SCRATCH_W1+1")
else else
asmgen.out(" lda #0 | sta P8ZP_SCRATCH_W1+1") asmgen.out(" lda #0 | sta P8ZP_SCRATCH_W1+1")
@ -1093,7 +1092,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
"&", "and" -> { "&", "and" -> {
asmgen.out(" lda $otherName | and $name | sta $name") asmgen.out(" lda $otherName | and $name | sta $name")
if(dt in WordDatatypes) { if(dt in WordDatatypes) {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name+1") asmgen.out(" stz $name+1")
else else
asmgen.out(" lda #0 | sta $name+1") asmgen.out(" lda #0 | sta $name+1")
@ -1352,7 +1351,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
asmgen.assignExpressionToRegister(value, RegisterOrPair.A) asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
asmgen.out(" and $name | sta $name") asmgen.out(" and $name | sta $name")
if(dt in WordDatatypes) { if(dt in WordDatatypes) {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz $name+1") asmgen.out(" stz $name+1")
else else
asmgen.out(" lda #0 | sta $name+1") asmgen.out(" lda #0 | sta $name+1")
@ -1475,7 +1474,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
asmgen.saveRegisterLocal(CpuRegister.X, scope) asmgen.saveRegisterLocal(CpuRegister.X, scope)
when (operator) { when (operator) {
"**" -> { "**" -> {
if(ICompilationTarget.instance is Cx16Target) { if(asmgen.compTarget is Cx16Target) {
// cx16 doesn't have FPWR() only FPWRT() // cx16 doesn't have FPWR() only FPWRT()
asmgen.out(""" asmgen.out("""
lda #<$name lda #<$name
@ -1553,7 +1552,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
asmgen.saveRegisterLocal(CpuRegister.X, scope) asmgen.saveRegisterLocal(CpuRegister.X, scope)
when (operator) { when (operator) {
"**" -> { "**" -> {
if(ICompilationTarget.instance is Cx16Target) { if(asmgen.compTarget is Cx16Target) {
// cx16 doesn't have FPWR() only FPWRT() // cx16 doesn't have FPWR() only FPWRT()
asmgen.out(""" asmgen.out("""
lda #<$name lda #<$name
@ -1645,7 +1644,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
when(target.kind) { when(target.kind) {
TargetStorageKind.VARIABLE -> { TargetStorageKind.VARIABLE -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz ${target.asmVarname}+1") asmgen.out(" stz ${target.asmVarname}+1")
else else
asmgen.out(" lda #0 | sta ${target.asmVarname}+1") asmgen.out(" lda #0 | sta ${target.asmVarname}+1")
@ -1655,7 +1654,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
asmgen.out(" lda #0 | sta ${target.asmVarname},y") asmgen.out(" lda #0 | sta ${target.asmVarname},y")
} }
TargetStorageKind.STACK -> { TargetStorageKind.STACK -> {
if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02)
asmgen.out(" stz P8ESTACK_HI+1,x") asmgen.out(" stz P8ESTACK_HI+1,x")
else else
asmgen.out(" lda #0 | sta P8ESTACK_HI+1,x") asmgen.out(" lda #0 | sta P8ESTACK_HI+1,x")