mirror of
https://github.com/irmen/prog8.git
synced 2024-10-06 09:58:13 +00:00
better names
This commit is contained in:
parent
84ec1be8a4
commit
ffb47458ff
@ -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)
|
||||
|
||||
}
|
||||
|
||||
|
@ -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")
|
||||
|
@ -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")
|
||||
|
Loading…
Reference in New Issue
Block a user