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

better names

Browse Source
This commit is contained in:
Irmen de Jong 2020-08-23 13:56:21 +02:00
parent 84ec1be8a4
commit ffb47458ff
3 changed files with 197 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,7 +9,7 @@ import prog8.ast.statements.DirectMemoryWrite
import prog8.compiler.AssemblyError
enum class AsmTargetStorageType {
enum class TargetStorageKind {
VARIABLE,
ARRAY,
MEMORY,
@ -17,41 +17,41 @@ enum class AsmTargetStorageType {
STACK
}
enum class AsmSourceStorageType {
enum class SourceStorageKind {
LITERALNUMBER,
VARIABLE,
ARRAY,
MEMORY,
REGISTER,
STACK, // value is already present on stack
EXPRESSION, // expression still to be evaluated
EXPRESSION, // expression in ast-form, still to be evaluated
}
internal class AsmAssignTarget(val type: AsmTargetStorageType,
internal class AsmAssignTarget(val kind: TargetStorageKind,
program: Program,
asmgen: AsmGen,
val datatype: DataType,
val astVariable: IdentifierReference?,
val astArray: ArrayIndexedExpression?,
val astMemory: DirectMemoryWrite?,
val variable: IdentifierReference?,
val array: ArrayIndexedExpression?,
val memory: DirectMemoryWrite?,
val register: RegisterOrPair?,
val origAstTarget: AssignTarget?, // TODO get rid of this eventually?
)
{
val constMemoryAddress by lazy { astMemory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
val constArrayIndexValue by lazy { astArray?.arrayspec?.size() ?: 0 }
val vardecl by lazy { astVariable?.targetVarDecl(program.namespace)!! }
val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
val constArrayIndexValue by lazy { array?.arrayspec?.size() ?: 0 }
val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! }
val asmName by lazy {
if(astVariable!=null)
asmgen.asmIdentifierName(astVariable)
if(variable!=null)
asmgen.asmIdentifierName(variable)
else
asmgen.asmIdentifierName(astArray!!.identifier)
asmgen.asmIdentifierName(array!!.identifier)
}
lateinit var origAssign: AsmAssignment
init {
if(astVariable!=null && vardecl.type == VarDeclType.CONST)
if(variable!=null && vardecl.type == VarDeclType.CONST)
throw AssemblyError("can't assign to a constant")
if(register!=null && datatype !in IntegerDatatypes)
throw AssemblyError("register must be integer type")
@ -61,71 +61,71 @@ internal class AsmAssignTarget(val type: AsmTargetStorageType,
fun fromAstAssignment(assign: Assignment, program: Program, asmgen: AsmGen): AsmAssignTarget = with(assign.target) {
val dt = inferType(program, assign).typeOrElse(DataType.STRUCT)
when {
identifier != null -> AsmAssignTarget(AsmTargetStorageType.VARIABLE, program, asmgen, dt, identifier, null, null, null, this)
arrayindexed != null -> AsmAssignTarget(AsmTargetStorageType.ARRAY, program, asmgen, dt, null, arrayindexed, null, null, this)
memoryAddress != null -> AsmAssignTarget(AsmTargetStorageType.MEMORY, program, asmgen, dt, null, null, memoryAddress, null, this)
identifier != null -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, identifier, null, null, null, this)
arrayindexed != null -> AsmAssignTarget(TargetStorageKind.ARRAY, program, asmgen, dt, null, arrayindexed, null, null, this)
memoryAddress != null -> AsmAssignTarget(TargetStorageKind.MEMORY, program, asmgen, dt, null, null, memoryAddress, null, this)
else -> throw AssemblyError("weird target")
}
}
}
}
internal class AsmAssignSource(val type: AsmSourceStorageType,
internal class AsmAssignSource(val kind: SourceStorageKind,
private val program: Program,
val datatype: DataType,
val astVariable: IdentifierReference? = null,
val astArray: ArrayIndexedExpression? = null,
val astMemory: DirectMemoryRead? = null,
val variable: IdentifierReference? = null,
val array: ArrayIndexedExpression? = null,
val memory: DirectMemoryRead? = null,
val register: CpuRegister? = null,
val numLitval: NumericLiteralValue? = null,
val astExpression: Expression? = null
val number: NumericLiteralValue? = null,
val expression: Expression? = null
)
{
val constMemoryAddress by lazy { astMemory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
val constArrayIndexValue by lazy { astArray?.arrayspec?.size() ?: 0 }
val vardecl by lazy { astVariable?.targetVarDecl(program.namespace)!! }
val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toInt() ?: 0}
val constArrayIndexValue by lazy { array?.arrayspec?.size() ?: 0 }
val vardecl by lazy { variable?.targetVarDecl(program.namespace)!! }
companion object {
fun fromAstSource(value: Expression, program: Program): AsmAssignSource {
val cv = value.constValue(program)
if(cv!=null)
return AsmAssignSource(AsmSourceStorageType.LITERALNUMBER, program, cv.type, numLitval = cv)
return AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, cv.type, number = cv)
return when(value) {
is NumericLiteralValue -> AsmAssignSource(AsmSourceStorageType.LITERALNUMBER, program, value.type, numLitval = cv)
is NumericLiteralValue -> AsmAssignSource(SourceStorageKind.LITERALNUMBER, program, value.type, number = cv)
is StringLiteralValue -> throw AssemblyError("string literal value should not occur anymore for asm generation")
is ArrayLiteralValue -> throw AssemblyError("array literal value should not occur anymore for asm generation")
is IdentifierReference -> {
val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
AsmAssignSource(AsmSourceStorageType.VARIABLE, program, dt, astVariable = value)
AsmAssignSource(SourceStorageKind.VARIABLE, program, dt, variable = value)
}
is DirectMemoryRead -> {
AsmAssignSource(AsmSourceStorageType.MEMORY, program, DataType.UBYTE, astMemory = value)
AsmAssignSource(SourceStorageKind.MEMORY, program, DataType.UBYTE, memory = value)
}
is ArrayIndexedExpression -> {
val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
AsmAssignSource(AsmSourceStorageType.ARRAY, program, dt, astArray = value)
AsmAssignSource(SourceStorageKind.ARRAY, program, dt, array = value)
}
else -> {
val dt = value.inferType(program).typeOrElse(DataType.STRUCT)
AsmAssignSource(AsmSourceStorageType.EXPRESSION, program, dt, astExpression = value)
AsmAssignSource(SourceStorageKind.EXPRESSION, program, dt, expression = value)
}
}
}
}
fun getAstValue(): Expression = when(type) {
AsmSourceStorageType.LITERALNUMBER -> numLitval!!
AsmSourceStorageType.VARIABLE -> astVariable!!
AsmSourceStorageType.ARRAY -> astArray!!
AsmSourceStorageType.MEMORY -> astMemory!!
AsmSourceStorageType.EXPRESSION -> astExpression!!
AsmSourceStorageType.REGISTER -> TODO()
AsmSourceStorageType.STACK -> TODO()
fun getAstValue(): Expression = when(kind) {
SourceStorageKind.LITERALNUMBER -> number!!
SourceStorageKind.VARIABLE -> variable!!
SourceStorageKind.ARRAY -> array!!
SourceStorageKind.MEMORY -> memory!!
SourceStorageKind.EXPRESSION -> expression!!
SourceStorageKind.REGISTER -> TODO()
SourceStorageKind.STACK -> TODO()
}
fun withAdjustedDt(newType: DataType) =
AsmAssignSource(type, program, newType, astVariable, astArray, astMemory, register, numLitval, astExpression)
AsmAssignSource(kind, program, newType, variable, array, memory, register, number, expression)
}

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

@ -34,8 +34,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val assign = AsmAssignment(source, target, assignment.isAugmentable, assignment.position)
when {
source.type==AsmSourceStorageType.LITERALNUMBER -> translateConstantValueAssignment(assign)
source.type==AsmSourceStorageType.VARIABLE -> translateVariableAssignment(assign)
source.kind==SourceStorageKind.LITERALNUMBER -> translateConstantValueAssignment(assign)
source.kind==SourceStorageKind.VARIABLE -> translateVariableAssignment(assign)
assign.isAugmentable -> augmentableAsmGen.translate(assign)
else -> translateOtherAssignment(assign)
}
@ -51,7 +51,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun translateVariableAssignment(assign: AsmAssignment) {
val identifier = assign.source.astVariable!!
val identifier = assign.source.variable!!
when (assign.target.datatype) {
DataType.UBYTE, DataType.BYTE -> assignFromByteVariable(assign.target, identifier)
DataType.UWORD, DataType.WORD -> assignFromWordVariable(assign.target, identifier)
@ -62,7 +62,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun translateConstantValueAssignment(assign: AsmAssignment) {
val numVal = assign.source.numLitval!!
val numVal = assign.source.number!!
when (numVal.type) {
DataType.UBYTE, DataType.BYTE -> assignFromByteConstant(assign.target, numVal.number.toShort())
DataType.UWORD, DataType.WORD -> assignFromWordConstant(assign.target, numVal.number.toInt())
@ -74,13 +74,13 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
internal fun translateOtherAssignment(assign: AsmAssignment) {
// source: expression, register, stack (only expression implemented for now)
when(assign.source.type) {
AsmSourceStorageType.LITERALNUMBER,
AsmSourceStorageType.VARIABLE -> {
throw AssemblyError("assignment value type ${assign.source.type} should have been handled elsewhere")
when(assign.source.kind) {
SourceStorageKind.LITERALNUMBER,
SourceStorageKind.VARIABLE -> {
throw AssemblyError("assignment value type ${assign.source.kind} should have been handled elsewhere")
}
AsmSourceStorageType.ARRAY -> {
val value = assign.source.astArray!!
SourceStorageKind.ARRAY -> {
val value = assign.source.array!!
val elementDt = value.inferType(program).typeOrElse(DataType.STRUCT)
val index = value.arrayspec.index
if (index is NumericLiteralValue) {
@ -103,8 +103,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
assignFromEvalResult(assign.target)
}
AsmSourceStorageType.MEMORY -> {
val value = assign.source.astMemory!!
SourceStorageKind.MEMORY -> {
val value = assign.source.memory!!
when (value.addressExpression) {
is NumericLiteralValue -> {
val address = (value.addressExpression as NumericLiteralValue).number.toInt()
@ -120,8 +120,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
}
}
AsmSourceStorageType.EXPRESSION -> {
val value = assign.source.astExpression!!
SourceStorageKind.EXPRESSION -> {
val value = assign.source.expression!!
if (value is AddressOf) {
assignFromAddressOf(assign.target, value.identifier)
}
@ -130,10 +130,10 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
assignFromEvalResult(assign.target)
}
}
AsmSourceStorageType.REGISTER -> {
SourceStorageKind.REGISTER -> {
assignByteFromRegister(assign.target, assign.source.register!!)
}
AsmSourceStorageType.STACK -> {
SourceStorageKind.STACK -> {
when(assign.source.datatype) {
in ByteDatatypes -> {
asmgen.out(" jsr prog8_lib.read_byte_from_address_on_stack | inx")
@ -148,8 +148,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun assignFromEvalResult(target: AsmAssignTarget) {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
when (target.datatype) {
DataType.UBYTE, DataType.BYTE -> {
asmgen.out(" inx | lda $ESTACK_LO_HEX,x | sta ${target.asmName}")
@ -173,19 +173,19 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
else -> throw AssemblyError("weird target variable type ${target.datatype}")
}
}
AsmTargetStorageType.MEMORY -> {
TargetStorageKind.MEMORY -> {
asmgen.out(" inx")
storeByteViaRegisterAInMemoryAddress("$ESTACK_LO_HEX,x", target.astMemory!!)
storeByteViaRegisterAInMemoryAddress("$ESTACK_LO_HEX,x", target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val targetArrayIdx = target.astArray!!
TargetStorageKind.ARRAY -> {
val targetArrayIdx = target.array!!
val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
asmgen.translateExpression(targetArrayIdx.arrayspec.index)
asmgen.out(" inx | lda $ESTACK_LO_HEX,x")
popAndWriteArrayvalueWithIndexA(arrayDt, target.asmName)
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
@ -203,8 +203,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.fixNameSymbols(name.nameInSource.joinToString("."))
}
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda #<$sourceName
ldy #>$sourceName
@ -212,23 +212,23 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sty ${target.asmName}+1
""")
}
AsmTargetStorageType.MEMORY -> {
TargetStorageKind.MEMORY -> {
throw AssemblyError("no asm gen for assign address $sourceName to memory word $target")
}
AsmTargetStorageType.ARRAY -> {
val targetArrayIdx = target.astArray!!
TargetStorageKind.ARRAY -> {
val targetArrayIdx = target.array!!
val index = targetArrayIdx.arrayspec.index
throw AssemblyError("no asm gen for assign address $sourceName to array ${target.asmName} [ $index ]")
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
private fun assignFromWordVariable(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda $sourceName
ldy $sourceName+1
@ -236,11 +236,11 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sty ${target.asmName}+1
""")
}
AsmTargetStorageType.MEMORY -> {
throw AssemblyError("no asm gen for assign wordvar $sourceName to memory ${target.astMemory}")
TargetStorageKind.MEMORY -> {
throw AssemblyError("no asm gen for assign wordvar $sourceName to memory ${target.memory}")
}
AsmTargetStorageType.ARRAY -> {
val targetArrayIdx = target.astArray!!
TargetStorageKind.ARRAY -> {
val targetArrayIdx = target.array!!
val index = targetArrayIdx.arrayspec.index
asmgen.out(" lda $sourceName | sta $ESTACK_LO_HEX,x | lda $sourceName+1 | sta $ESTACK_HI_HEX,x | dex")
asmgen.translateExpression(index)
@ -248,15 +248,15 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
popAndWriteArrayvalueWithIndexA(arrayDt, target.asmName)
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
private fun assignFromFloatVariable(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda $sourceName
sta ${target.asmName}
@ -270,9 +270,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sta ${target.asmName}+4
""")
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.array.identifier)
asmgen.out(" lda #<$sourceName | ldy #>$sourceName | jsr c64flt.push_float")
asmgen.translateExpression(index)
asmgen.out(" lda #<$targetName | ldy #>$targetName | jsr c64flt.pop_float_to_indexed_var")
@ -283,18 +283,18 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
private fun assignFromByteVariable(target: AsmAssignTarget, variable: IdentifierReference) {
val sourceName = asmgen.asmIdentifierName(variable)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda $sourceName
sta ${target.asmName}
""")
}
AsmTargetStorageType.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(sourceName, target.astMemory!!)
TargetStorageKind.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(sourceName, target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val targetArrayIdx = target.astArray!!
TargetStorageKind.ARRAY -> {
val targetArrayIdx = target.array!!
val index = targetArrayIdx.arrayspec.index
val arrayDt = targetArrayIdx.identifier.inferType(program).typeOrElse(DataType.STRUCT)
asmgen.out(" lda $sourceName | sta $ESTACK_LO_HEX,x | dex")
@ -302,22 +302,22 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
asmgen.out(" inx | lda $ESTACK_LO_HEX,x")
popAndWriteArrayvalueWithIndexA(arrayDt, target.asmName)
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
private fun assignByteFromRegister(target: AsmAssignTarget, register: CpuRegister) {
require(target.datatype in ByteDatatypes)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out(" st${register.name.toLowerCase()} ${target.asmName}")
}
AsmTargetStorageType.MEMORY -> {
storeRegisterInMemoryAddress(register, target.astMemory!!)
TargetStorageKind.MEMORY -> {
storeRegisterInMemoryAddress(register, target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val targetArrayIdx = target.astArray!!
TargetStorageKind.ARRAY -> {
val targetArrayIdx = target.array!!
val index = targetArrayIdx.arrayspec.index
when (index) {
is NumericLiteralValue -> {
@ -360,8 +360,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
}
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
@ -439,8 +439,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
}
private fun assignFromWordConstant(target: AsmAssignTarget, word: Int) {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
if (word ushr 8 == word and 255) {
// lsb=msb
asmgen.out("""
@ -457,12 +457,12 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
""")
}
}
AsmTargetStorageType.MEMORY -> {
throw AssemblyError("no asm gen for assign word $word to memory ${target.astMemory}")
TargetStorageKind.MEMORY -> {
throw AssemblyError("no asm gen for assign word $word to memory ${target.memory}")
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.array.identifier)
asmgen.translateExpression(index)
asmgen.out("""
inx
@ -475,22 +475,22 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sta $targetName+1,y
""")
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
private fun assignFromByteConstant(target: AsmAssignTarget, byte: Short) {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out(" lda #${byte.toHex()} | sta ${target.asmName} ")
}
AsmTargetStorageType.MEMORY -> {
storeByteViaRegisterAInMemoryAddress("#${byte.toHex()}", target.astMemory!!)
TargetStorageKind.MEMORY -> {
storeByteViaRegisterAInMemoryAddress("#${byte.toHex()}", target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.array.identifier)
asmgen.translateExpression(index)
asmgen.out("""
inx
@ -506,8 +506,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
private fun assignFromFloatConstant(target: AsmAssignTarget, float: Double) {
if (float == 0.0) {
// optimized case for float zero
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda #0
sta ${target.asmName}
@ -517,8 +517,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sta ${target.asmName}+4
""")
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
if (index is NumericLiteralValue) {
val indexValue = index.number.toInt() * C64MachineDefinition.FLOAT_MEM_SIZE
asmgen.out("""
@ -545,8 +545,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
} else {
// non-zero value
val constFloat = asmgen.getFloatConst(float)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda $constFloat
sta ${target.asmName}
@ -560,9 +560,9 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
sta ${target.asmName}+4
""")
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val arrayVarName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val arrayVarName = asmgen.asmIdentifierName(target.array.identifier)
if (index is NumericLiteralValue) {
val indexValue = index.number.toInt() * C64MachineDefinition.FLOAT_MEM_SIZE
asmgen.out("""
@ -599,28 +599,28 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
private fun assignFromMemoryByte(target: AsmAssignTarget, address: Int?, identifier: IdentifierReference?) {
if (address != null) {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda ${address.toHex()}
sta ${target.asmName}
""")
}
AsmTargetStorageType.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(address.toHex(), target.astMemory!!)
TargetStorageKind.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(address.toHex(), target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.array.identifier)
throw AssemblyError("no asm gen for assign memory byte at $address to array $targetName [ $index ]")
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
} else if (identifier != null) {
val sourceName = asmgen.asmIdentifierName(identifier)
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda $sourceName
sta ${C64Zeropage.SCRATCH_W1}
@ -630,12 +630,12 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${target.asmName}""")
}
AsmTargetStorageType.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(sourceName, target.astMemory!!)
TargetStorageKind.MEMORY -> {
storeByteViaRegisterAInMemoryAddress(sourceName, target.memory!!)
}
AsmTargetStorageType.ARRAY -> {
val index = target.astArray!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.astArray.identifier)
TargetStorageKind.ARRAY -> {
val index = target.array!!.arrayspec.index
val targetName = asmgen.asmIdentifierName(target.array.identifier)
throw AssemblyError("no asm gen for assign memory byte $sourceName to array $targetName [ $index ]")
}
else -> throw AssemblyError("no asm gen for assign memory byte $target")

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

@ -14,9 +14,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
private val asmgen: AsmGen) {
fun translate(assign: AsmAssignment) {
require(assign.isAugmentable)
require(assign.source.type==AsmSourceStorageType.EXPRESSION)
require(assign.source.kind==SourceStorageKind.EXPRESSION)
val value = assign.source.astExpression!!
val value = assign.source.expression!!
when (value) {
is PrefixExpression -> {
// A = -A , A = +A, A = ~A, A = not A
@ -105,8 +105,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
val valueLv = (value as? NumericLiteralValue)?.number
val ident = value as? IdentifierReference
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
when (target.datatype) {
in ByteDatatypes -> {
when {
@ -159,8 +159,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
}
}
AsmTargetStorageType.MEMORY -> {
val memory = target.astMemory!!
TargetStorageKind.MEMORY -> {
val memory = target.memory!!
when (memory.addressExpression) {
is NumericLiteralValue -> {
val addr = (memory.addressExpression as NumericLiteralValue).number.toInt()
@ -208,12 +208,12 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
}
}
}
AsmTargetStorageType.ARRAY -> {
println("*** TODO optimize simple inplace array assignment ${target.astArray} $operator= $value")
TargetStorageKind.ARRAY -> {
println("*** TODO optimize simple inplace array assignment ${target.array} $operator= $value")
assignmentAsmGen.translateOtherAssignment(target.origAssign) // TODO get rid of this fallback for the most common cases here
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
@ -1018,7 +1018,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
DataType.UWORD, DataType.WORD -> {
when (outerCastDt) {
DataType.UBYTE, DataType.BYTE -> {
if(target.type==AsmTargetStorageType.VARIABLE) {
if(target.kind==TargetStorageKind.VARIABLE) {
asmgen.out(" lda #0 | sta ${target.asmName}+1")
} else
throw AssemblyError("weird value")
@ -1048,8 +1048,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
private fun inplaceBooleanNot(target: AsmAssignTarget, dt: DataType) {
when (dt) {
DataType.UBYTE -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda ${target.asmName}
beq +
@ -1057,8 +1057,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
+ eor #1
sta ${target.asmName}""")
}
AsmTargetStorageType.MEMORY-> {
val mem = target.astMemory!!
TargetStorageKind.MEMORY-> {
val mem = target.memory!!
when (mem.addressExpression) {
is NumericLiteralValue -> {
val addr = (mem.addressExpression as NumericLiteralValue).number.toHex()
@ -1096,16 +1096,16 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
}
}
}
AsmTargetStorageType.ARRAY -> {
TargetStorageKind.ARRAY -> {
TODO("in-place not of ubyte array")
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
DataType.UWORD -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda ${target.asmName}
ora ${target.asmName}+1
@ -1116,10 +1116,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
lsr a
sta ${target.asmName}+1""")
}
AsmTargetStorageType.MEMORY -> throw AssemblyError("no asm gen for uword-memory not")
AsmTargetStorageType.ARRAY -> TODO("in-place not of uword array")
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.MEMORY -> throw AssemblyError("no asm gen for uword-memory not")
TargetStorageKind.ARRAY -> TODO("in-place not of uword array")
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
else -> throw AssemblyError("boolean-not of invalid type")
@ -1129,15 +1129,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
private fun inplaceInvert(target: AsmAssignTarget, dt: DataType) {
when (dt) {
DataType.UBYTE -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda ${target.asmName}
eor #255
sta ${target.asmName}""")
}
AsmTargetStorageType.MEMORY -> {
val memory = target.astMemory!!
TargetStorageKind.MEMORY -> {
val memory = target.memory!!
when (memory.addressExpression) {
is NumericLiteralValue -> {
val addr = (memory.addressExpression as NumericLiteralValue).number.toHex()
@ -1169,16 +1169,16 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
}
}
}
AsmTargetStorageType.ARRAY -> {
TargetStorageKind.ARRAY -> {
TODO("in-place invert ubyte array")
}
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
DataType.UWORD -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda ${target.asmName}
eor #255
@ -1187,10 +1187,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
eor #255
sta ${target.asmName}+1""")
}
AsmTargetStorageType.MEMORY -> throw AssemblyError("no asm gen for uword-memory invert")
AsmTargetStorageType.ARRAY -> TODO("in-place invert uword array")
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.MEMORY -> throw AssemblyError("no asm gen for uword-memory invert")
TargetStorageKind.ARRAY -> TODO("in-place invert uword array")
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
else -> throw AssemblyError("invert of invalid type")
@ -1200,23 +1200,23 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
private fun inplaceNegate(target: AsmAssignTarget, dt: DataType) {
when (dt) {
DataType.BYTE -> {
when (target.type) {
AsmTargetStorageType.VARIABLE -> {
when (target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda #0
sec
sbc ${target.asmName}
sta ${target.asmName}""")
}
AsmTargetStorageType.MEMORY -> throw AssemblyError("can't in-place negate memory ubyte")
AsmTargetStorageType.ARRAY -> TODO("in-place negate byte array")
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.MEMORY -> throw AssemblyError("can't in-place negate memory ubyte")
TargetStorageKind.ARRAY -> TODO("in-place negate byte array")
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
DataType.WORD -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
lda #0
sec
@ -1226,15 +1226,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
sbc ${target.asmName}+1
sta ${target.asmName}+1""")
}
AsmTargetStorageType.ARRAY -> TODO("in-place negate word array")
AsmTargetStorageType.MEMORY -> throw AssemblyError("no asm gen for word memory negate")
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.ARRAY -> TODO("in-place negate word array")
TargetStorageKind.MEMORY -> throw AssemblyError("no asm gen for word memory negate")
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
DataType.FLOAT -> {
when(target.type) {
AsmTargetStorageType.VARIABLE -> {
when(target.kind) {
TargetStorageKind.VARIABLE -> {
asmgen.out("""
stx ${C64Zeropage.SCRATCH_REG_X}
lda #<${target.asmName}
@ -1247,10 +1247,10 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
ldx ${C64Zeropage.SCRATCH_REG_X}
""")
}
AsmTargetStorageType.ARRAY -> TODO("in-place negate float array")
AsmTargetStorageType.MEMORY -> throw AssemblyError("no asm gen for float memory negate")
AsmTargetStorageType.REGISTER -> TODO()
AsmTargetStorageType.STACK -> TODO()
TargetStorageKind.ARRAY -> TODO("in-place negate float array")
TargetStorageKind.MEMORY -> throw AssemblyError("no asm gen for float memory negate")
TargetStorageKind.REGISTER -> TODO()
TargetStorageKind.STACK -> TODO()
}
}
else -> throw AssemblyError("negate of invalid type")