From 3502f65332abd910c26e50330de8607ff4ffb830 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Tue, 9 Feb 2021 19:03:21 +0100 Subject: [PATCH] reducing dependencies --- .../compiler/target/c64/AssemblyProgram.kt | 7 +-- .../compiler/target/c64/codegen/AsmGen.kt | 6 +- .../c64/codegen/BuiltinFunctionsAsmGen.kt | 9 ++- .../target/c64/codegen/ExpressionsAsmGen.kt | 9 ++- .../target/c64/codegen/FunctionCallAsmGen.kt | 3 +- .../target/c64/codegen/PostIncrDecrAsmGen.kt | 3 +- .../codegen/assignment/AssignmentAsmGen.kt | 57 +++++++++---------- .../assignment/AugmentableAssignmentAsmGen.kt | 35 ++++++------ 8 files changed, 61 insertions(+), 68 deletions(-) diff --git a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt index 1eb4df94a..fee3fcf17 100644 --- a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt +++ b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt @@ -2,13 +2,12 @@ package prog8.compiler.target.c64 import prog8.compiler.CompilationOptions import prog8.compiler.OutputType -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.IAssemblyProgram import prog8.compiler.target.generatedLabelPrefix import java.nio.file.Path 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 prgFile = outputDir.resolve("$name.prg") 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) { OutputType.PRG -> { command.add("--cbm-prg") - println("\nCreating prg for target ${ICompilationTarget.instance.name}.") + println("\nCreating prg for target $compTarget.") prgFile } OutputType.RAW -> { command.add("--nostart") - println("\nCreating raw binary for target ${ICompilationTarget.instance.name}.") + println("\nCreating raw binary for target $compTarget.") binFile } } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt index 925979bc0..116d73084 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt @@ -25,7 +25,7 @@ internal class AsmGen(private val program: Program, val errors: ErrorReporter, val zeropage: Zeropage, val options: CompilationOptions, - private val compTarget: ICompilationTarget, + val compTarget: ICompilationTarget, private val outputDir: Path): IAssemblyGenerator { // for expressions and augmented assignments: @@ -40,7 +40,7 @@ internal class AsmGen(private val program: Program, private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this) private val functioncallAsmGen = FunctionCallAsmGen(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) internal val loopEndLabels = ArrayDeque() private val blockLevelVarInits = mutableMapOf>() @@ -85,7 +85,7 @@ internal class AsmGen(private val program: Program, } } - return AssemblyProgram(program.name, outputDir) + return AssemblyProgram(program.name, outputDir, compTarget.name) } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt index d7014fc5c..ce76e38c0 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt @@ -9,7 +9,6 @@ import prog8.ast.statements.* import prog8.ast.toHex import prog8.compiler.AssemblyError import prog8.compiler.functions.FSignature -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.c64.codegen.assignment.* 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) { - val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) - val index2 = indexValue2.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) + val index1 = indexValue1.number.toInt() * asmgen.compTarget.memorySize(elementDt) + val index2 = indexValue2.number.toInt() * asmgen.compTarget.memorySize(elementDt) when(elementDt) { DataType.UBYTE, DataType.BYTE -> { 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) { - val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt) + val index1 = indexValue1.number.toInt() * asmgen.compTarget.memorySize(elementDt) val idxAsmName2 = asmgen.asmVariableName(indexName2) when(elementDt) { 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) { 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) { DataType.UBYTE, DataType.BYTE -> { asmgen.out(""" diff --git a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt index 83b8e2f80..da43ea0ff 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt @@ -9,7 +9,6 @@ import prog8.ast.statements.Subroutine import prog8.ast.toHex import prog8.compiler.AssemblyError import prog8.compiler.functions.BuiltinFunctions -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.CpuType import prog8.compiler.target.subroutineFloatEvalResultVar1 import kotlin.math.absoluteValue @@ -1394,7 +1393,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge when(typecast.type) { DataType.UBYTE, DataType.BYTE -> {} 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") else 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() { 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) { asmgen.out(" lda (P8ZP_SCRATCH_W2) | dex | sta P8ESTACK_LO+1,x") } else { @@ -1674,7 +1673,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge } DataType.UWORD -> { 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") else 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 arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar) 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) { in ByteDatatypes -> { asmgen.out(" lda $arrayVarName+$indexValue | sta P8ESTACK_LO,x | dex") diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt index 2a9698c32..b583ebae1 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt @@ -7,7 +7,6 @@ import prog8.ast.base.* import prog8.ast.expressions.* import prog8.ast.statements.* import prog8.compiler.AssemblyError -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.CpuType import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource 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 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") else asmgen.out(" lda #0 | sta cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1") diff --git a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt index 30b3ad28b..14934d9dd 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt @@ -7,7 +7,6 @@ import prog8.ast.expressions.NumericLiteralValue import prog8.ast.statements.PostIncrDecr import prog8.ast.toHex import prog8.compiler.AssemblyError -import prog8.compiler.target.ICompilationTarget 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 elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT) 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) { in ByteDatatypes -> asmgen.out(if (incr) " inc $asmArrayvarname+$indexValue" else " dec $asmArrayvarname+$indexValue") in WordDatatypes -> { diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt index b9e0c78f3..9bc42c524 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt @@ -9,13 +9,12 @@ import prog8.compiler.AssemblyError import prog8.compiler.functions.BuiltinFunctions import prog8.compiler.functions.builtinFunctionReturnType import prog8.compiler.target.CpuType -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.c64.codegen.AsmGen import prog8.compiler.target.c64.codegen.ExpressionsAsmGen 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) @@ -67,7 +66,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen val arrayVarName = asmgen.asmVariableName(value.arrayvar) if (value.indexer.indexNum!=null) { // constant array index value - val indexValue = value.indexer.constIndex()!! * compTarget.memorySize(elementDt) + val indexValue = value.indexer.constIndex()!! * asmgen.compTarget.memorySize(elementDt) when (elementDt) { in ByteDatatypes -> { asmgen.out(" lda $arrayVarName+$indexValue") @@ -115,7 +114,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen SourceStorageKind.MEMORY -> { fun assignViaExprEval(expression: Expression) { 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)") else 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) { 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)") else 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") } 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") else 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") } DataType.UWORD -> { - if(compTarget.machine.cpu==CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu==CpuType.CPU65c02) asmgen.out(" lda $sourceAsmVarName | sta $targetAsmVarName | stz $targetAsmVarName+1") else 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") } 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") else 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") } 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") else 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 -> { if(target.constArrayIndexValue!=null) { - val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype) + val scaledIdx = target.constArrayIndexValue!! * asmgen.compTarget.memorySize(target.datatype) when(target.datatype) { in ByteDatatypes -> { 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 -> { target.array!! if(target.constArrayIndexValue!=null) { - val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype) + val scaledIdx = target.constArrayIndexValue!! * asmgen.compTarget.memorySize(target.datatype) when(target.datatype) { in ByteDatatypes -> { asmgen.out(" lda $sourceName | sta ${target.asmVarname}+$scaledIdx") @@ -1192,7 +1191,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen } TargetStorageKind.ARRAY -> { 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") } else { @@ -1296,7 +1295,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen when(wordtarget.kind) { TargetStorageKind.VARIABLE -> { 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") else 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) { val scaledIdx = wordtarget.constArrayIndexValue!! * 2 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") else 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 -> { 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") else 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) { - if(word==0 && compTarget.machine.cpu == CpuType.CPU65c02) { + if(word==0 && asmgen.compTarget.machine.cpu == CpuType.CPU65c02) { // optimize setting zero value for this processor when(target.kind) { TargetStorageKind.VARIABLE -> { @@ -1667,7 +1666,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen } 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 when(target.kind) { 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") in Cx16VirtualRegisters -> { 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") else 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 when(target.kind) { TargetStorageKind.VARIABLE -> { - if(compTarget.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(""" stz ${target.asmVarname} stz ${target.asmVarname}+1 @@ -1778,8 +1777,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen } TargetStorageKind.ARRAY -> { if (target.array!!.indexer.indexNum!=null) { - val indexValue = target.array.indexer.constIndex()!! * compTarget.memorySize(DataType.FLOAT) - if(compTarget.machine.cpu == CpuType.CPU65c02) + val indexValue = target.array.indexer.constIndex()!! * asmgen.compTarget.memorySize(DataType.FLOAT) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(""" stz ${target.asmVarname}+$indexValue stz ${target.asmVarname}+$indexValue+1 @@ -1843,7 +1842,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen TargetStorageKind.ARRAY -> { val arrayVarName = target.asmVarname 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(""" lda $constFloat sta $arrayVarName+$indexValue @@ -1976,7 +1975,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen when(wordtarget.kind) { TargetStorageKind.VARIABLE -> { 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") else asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1") @@ -1992,7 +1991,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen } TargetStorageKind.STACK -> { 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") else 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 -> { asmgen.loadByteFromPointerIntoA(identifier) asmgen.out(" sta ${wordtarget.asmVarname}") - if(compTarget.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz ${wordtarget.asmVarname}+1") else asmgen.out(" lda #0 | sta ${wordtarget.asmVarname}+1") @@ -2024,7 +2023,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen TargetStorageKind.STACK -> { asmgen.loadByteFromPointerIntoA(identifier) 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") else 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) { is NumericLiteralValue, is IdentifierReference -> { 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)") else 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") assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null) asmgen.out(" pla") - if (compTarget.machine.cpu == CpuType.CPU65c02) + if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" sta (P8ZP_SCRATCH_W2)") else 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 vardecl = pointervar.targetVarDecl(program)!! val scopedName = vardecl.makeScopedName(vardecl.name) - if (compTarget.machine.cpu == CpuType.CPU65c02) { + if (asmgen.compTarget.machine.cpu == CpuType.CPU65c02) { if (asmgen.isZpVar(scopedName)) { // pointervar is already in the zero page, no need to copy asmgen.out(" sta ($sourceName)") diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt index 251befb38..91007b899 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt @@ -6,7 +6,6 @@ import prog8.ast.expressions.* import prog8.ast.statements.Subroutine import prog8.ast.toHex import prog8.compiler.AssemblyError -import prog8.compiler.target.ICompilationTarget import prog8.compiler.target.CpuType import prog8.compiler.target.Cx16Target import prog8.compiler.target.c64.codegen.AsmGen @@ -202,7 +201,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, with(target.array!!.indexer) { when { 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) { in ByteDatatypes -> { when { @@ -632,7 +631,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, } "<<" -> { if(value>=8) { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name") else asmgen.out(" lda #0 | sta $name") @@ -643,7 +642,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, if(value>0) { if (dt == DataType.UBYTE) { if(value>=8) { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name") else asmgen.out(" lda #0 | sta $name") @@ -858,14 +857,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, "<<" -> { when { value>=16 -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name | stz $name+1") else asmgen.out(" lda #0 | sta $name | sta $name+1") } value==8 -> { 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") else asmgen.out(" lda #0 | sta $name") @@ -885,14 +884,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, if(dt==DataType.UWORD) { when { value>=16 -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name | stz $name+1") else asmgen.out(" lda #0 | sta $name | sta $name+1") } value==8 -> { 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") else asmgen.out(" lda #0 | sta $name+1") @@ -941,13 +940,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, "&", "and" -> { when { value == 0 -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name | stz $name+1") else asmgen.out(" lda #0 | sta $name | sta $name+1") } value and 255 == 0 -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name") else asmgen.out(" lda #0 | sta $name") @@ -955,7 +954,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, } value < 0x0100 -> { 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") else 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") - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz P8ZP_SCRATCH_W1+1") else asmgen.out(" lda #0 | sta P8ZP_SCRATCH_W1+1") @@ -1093,7 +1092,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, "&", "and" -> { asmgen.out(" lda $otherName | and $name | sta $name") if(dt in WordDatatypes) { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name+1") else asmgen.out(" lda #0 | sta $name+1") @@ -1352,7 +1351,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, asmgen.assignExpressionToRegister(value, RegisterOrPair.A) asmgen.out(" and $name | sta $name") if(dt in WordDatatypes) { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz $name+1") else asmgen.out(" lda #0 | sta $name+1") @@ -1475,7 +1474,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, asmgen.saveRegisterLocal(CpuRegister.X, scope) when (operator) { "**" -> { - if(ICompilationTarget.instance is Cx16Target) { + if(asmgen.compTarget is Cx16Target) { // cx16 doesn't have FPWR() only FPWRT() asmgen.out(""" lda #<$name @@ -1553,7 +1552,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, asmgen.saveRegisterLocal(CpuRegister.X, scope) when (operator) { "**" -> { - if(ICompilationTarget.instance is Cx16Target) { + if(asmgen.compTarget is Cx16Target) { // cx16 doesn't have FPWR() only FPWRT() asmgen.out(""" lda #<$name @@ -1645,7 +1644,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, DataType.UBYTE, DataType.BYTE -> { when(target.kind) { TargetStorageKind.VARIABLE -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz ${target.asmVarname}+1") else 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") } TargetStorageKind.STACK -> { - if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) + if(asmgen.compTarget.machine.cpu == CpuType.CPU65c02) asmgen.out(" stz P8ESTACK_HI+1,x") else asmgen.out(" lda #0 | sta P8ESTACK_HI+1,x")