Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2025-08-09 19:25:22 +00:00
Code Issues Projects Releases Wiki Activity

assignments

Browse Source
This commit is contained in:
Irmen de Jong
2018-11-03 00:02:31 +01:00
parent d6432df90d
commit 783db2f88b
3 changed files with 455 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
compiler/examples/test.p8
View File

@@ -350,6 +350,65 @@ byte_assignment_to_bytearray:
; barr1[ubarr2[X]] = barr2[ubarr1[Y]] ; todo via evaluation-- check generated asm... ; barr1[ubarr2[X]] = barr2[ubarr1[Y]] ; todo via evaluation-- check generated asm...
byte_assignment_to_membytearray:
mbarr1[3] = 42
mbarr1[3] = b2
mbarr1[3] = mbyte2
mbarr1[3] = barr1[2]
mbarr1[3] = barr1[X]
mbarr1[3] = barr1[b]
mbarr1[3] = barr1[ub]
mbarr1[3] = barr1[mbyte2]
mbarr1[3] = barr1[mubyte2]
mbarr1[Y] = 42
mbarr1[Y] = b2
mbarr1[Y] = mbyte2
mbarr1[Y] = barr1[2]
mbarr1[Y] = barr1[X]
mbarr1[Y] = barr1[b]
mbarr1[Y] = barr1[ub]
mbarr1[Y] = barr1[mbyte2]
mbarr1[Y] = barr1[mubyte2]
mbarr1[b2] = 42
mbarr1[b2] = b2
mbarr1[b2] = mbyte2
mbarr1[b2] = barr1[2]
mbarr1[b2] = barr1[X]
mbarr1[b2] = barr1[b]
mbarr1[b2] = barr1[ub]
mbarr1[b2] = barr1[mbyte2]
mbarr1[b2] = barr1[mubyte2]
mbarr1[ub2] = 42
mbarr1[ub2] = b2
mbarr1[ub2] = mbyte2
mbarr1[ub2] = barr1[2]
mbarr1[ub2] = barr1[X]
mbarr1[ub2] = barr1[b]
mbarr1[ub2] = barr1[ub]
mbarr1[ub2] = barr1[mbyte2]
mbarr1[ub2] = barr1[mubyte2]
mbarr1[mubyte2] = 42
mbarr1[mubyte2] = b2
mbarr1[mubyte2] = mbyte2
mbarr1[mubyte2] = barr1[2]
; mbarr1[mubyte2] = string[X] ;;todo via evaluation
; mbarr1[mubyte2] = string[b] ;todo via evaluation
; mbarr1[mubyte2] = string[ub] ;todo via evaluation
; mbarr1[mubyte2] = string[mbyte2] ;todo via evaluation
; mbarr1[mubyte2] = string[mubyte2] ;todo via evaluation
; mbarr1[mubyte2] = ubarr1[X] ;todo via evaluation
; mbarr1[mubyte2] = ubarr1[b] ;todo via evaluation
; mbarr1[mubyte2] = ubarr1[ub] ;todo via evaluation
; mbarr1[mubyte2] = ubarr1[mbyte2] ;todo via evaluation
; mbarr1[mubyte2] = ubarr1[mubyte2] ;todo via evaluation
; mbarr1[ubarr2[X]] = barr2[ubarr1[Y]] ; todo via evaluation-- check generated asm...
@@ -368,21 +427,21 @@ uword_assignment_to_uwordvar:
uw = string[4] uw = string[4]
uw = ubarr1[2] uw = ubarr1[2]
uw = uwarr1[2] uw = uwarr1[2]
;uw = string[X] ; todo via evaluation uw = string[X]
;uw = string[b] ; todo via evaluation uw = string[b]
;uw = string[ub] ; todo via evaluation uw = string[ub]
;uw = string[mbyte2] ; todo via evaluation uw = string[mbyte2]
;uw = string[mubyte2] ; todo via evaluation uw = string[mubyte2]
; uw = ubarr1[X] ;; todo via evaluation uw = ubarr1[X]
; uw = ubarr1[b] ;; todo via evaluation uw = ubarr1[b]
; uw = ubarr1[ub] ; todo via evaluation uw = ubarr1[ub]
; uw = ubarr1[mbyte2] ; todo via evaluation uw = ubarr1[mbyte2]
; uw = ubarr1[mubyte2] ; todo via evaluation uw = ubarr1[mubyte2]
; uw = uwarr1[X] ; todo via evaluation uw = uwarr1[X]
; uw = uwarr1[b] ; todo via evaluation uw = uwarr1[b]
; uw = uwarr1[ub] ; todo via evaluation uw = uwarr1[ub]
; uw = uwarr1[mbyte2] ; todo via evaluation uw = uwarr1[mbyte2]
; uw = uwarr1[mubyte2] ; todo via evaluation uw = uwarr1[mubyte2]
uword_assignment_to_uwordmem: uword_assignment_to_uwordmem:
@@ -397,21 +456,21 @@ uword_assignment_to_uwordmem:
muword = string[4] muword = string[4]
muword = ubarr1[2] muword = ubarr1[2]
muword = uwarr1[2] muword = uwarr1[2]
; muword = string[X] ; todo via evaluation ; muword = string[X]
; muword = string[b] ; todo via evaluation ; muword = string[b]
; muword = string[ub] ; todo via evaluation ; muword = string[ub]
; muword = string[mbyte2] ; todo via evaluation ; muword = string[mbyte2]
; muword = string[mubyte2] ; todo via evaluation ; muword = string[mubyte2]
; muword = ubarr1[X] ; todo via evaluation ; muword = ubarr1[X]
; muword = ubarr1[b] ; todo via evaluation ; muword = ubarr1[b]
; muword = ubarr1[ub] ; todo via evaluation ; muword = ubarr1[ub]
; muword = ubarr1[mbyte2] ; todo via evaluation ; muword = ubarr1[mbyte2]
; muword = ubarr1[mubyte2] ; todo via evaluation ; muword = ubarr1[mubyte2]
; muword = uwarr1[X] ; todo via evaluation ; muword = uwarr1[X]
; muword = uwarr1[b] ; todo via evaluation ; muword = uwarr1[b]
; muword = uwarr1[ub] ; todo via evaluation ; muword = uwarr1[ub]
; muword = uwarr1[mbyte2] ; todo via evaluation ; muword = uwarr1[mbyte2]
; muword = uwarr1[mubyte2] ; todo via evaluation ; muword = uwarr1[mubyte2]
uword_assignment_to_uwordarray: uword_assignment_to_uwordarray:
@@ -521,26 +580,29 @@ word_assignment_to_wordvar:
w = barr1[2] w = barr1[2]
w = warr1[2] w = warr1[2]
; w = string[X] ; todo via evaluation w = string[X]
; w = string[b] ; todo via evaluation w = string[b]
; w = string[ub] ; todo via evaluation w = string[ub]
; w = string[mbyte2] ; todo via evaluation w = string[mbyte2]
; w = string[mubyte2] ; todo via evaluation w = string[mubyte2]
; w = barr1[X] ;; todo via evaluation
; w = ubarr1[X] ;; todo via evaluation
; w = barr1[b] ;; todo via evaluation ; @todo these:
; w = ubarr1[b] ;; todo via evaluation w = barr1[X]
; w = barr1[ub] ; todo via evaluation w = ubarr1[X]
; w = ubarr1[ub] ; todo via evaluation w = barr1[b]
; w = barr1[mbyte2] ; todo via evaluation w = ubarr1[b]
; w = ubarr1[mbyte2] ; todo via evaluation w = barr1[ub]
; w = barr1[mubyte2] ; todo via evaluation w = ubarr1[ub]
; w = ubarr1[mubyte2] ; todo via evaluation w = barr1[mbyte2]
; w = warr1[X] ; todo via evaluation w = ubarr1[mbyte2]
; w = warr1[b] ; todo via evaluation w = barr1[mubyte2]
; w = warr1[ub] ; todo via evaluation w = ubarr1[mubyte2]
; w = warr1[mbyte2] ; todo via evaluation w = warr1[X]
; w = warr1[mubyte2] ; todo via evaluation w = warr1[b]
w = warr1[ub]
w = warr1[mbyte2]
w = warr1[mubyte2]
word_assignment_to_wordmem: word_assignment_to_wordmem:
@@ -559,26 +621,31 @@ word_assignment_to_wordmem:
mword = barr1[2] mword = barr1[2]
mword = warr1[2] mword = warr1[2]
; mword = string[X] ; todo via evaluation
; mword = string[b] ; todo via evaluation ; @todo these:
; mword = string[ub] ; todo via evaluation mword = string[X]
; mword = string[mbyte2] ; todo via evaluation mword = string[b]
; mword = string[mubyte2] ; todo via evaluation mword = string[ub]
; mword = barr1[X] ;; todo via evaluation mword = string[mbyte2]
; mword = ubarr1[X] ;; todo via evaluation mword = string[mubyte2]
; mword = barr1[b] ;; todo via evaluation mword = barr1[X]
; mword = ubarr1[b] ;; todo via evaluation mword = ubarr1[X]
; mword = barr1[ub] ; todo via evaluation mword = barr1[b]
; mword = ubarr1[ub] ; todo via evaluation mword = ubarr1[b]
; mword = barr1[mbyte2] ; todo via evaluation mword = barr1[ub]
; mword = ubarr1[mbyte2] ; todo via evaluation mword = ubarr1[ub]
; mword = barr1[mubyte2] ; todo via evaluation mword = barr1[mbyte2]
; mword = ubarr1[mubyte2] ; todo via evaluation mword = ubarr1[mbyte2]
; mword = warr1[X] ; todo via evaluation mword = barr1[mubyte2]
; mword = warr1[b] ; todo via evaluation mword = ubarr1[mubyte2]
; mword = warr1[ub] ; todo via evaluation mword = warr1[X]
; mword = warr1[mbyte2] ; todo via evaluation mword = warr1[b]
; mword = warr1[mubyte2] ; todo via evaluation mword = warr1[ub]
mword = warr1[mbyte2]
mword = warr1[mubyte2]
; @todo assignment to word array
;; all possible assignments to a FLOAT VARIABLE ;; all possible assignments to a FLOAT VARIABLE

5
compiler/src/prog8/ast/AST.kt
View File

@@ -693,8 +693,7 @@ data class AssignTarget(val register: Register?,
if(dt!=null) if(dt!=null)
return dt return dt
} }
return null
throw FatalAstException("cannot determine datatype of assignment target $this")
} }
} }
@@ -897,7 +896,7 @@ class ArrayIndexedExpression(val identifier: IdentifierReference?,
else -> throw FatalAstException("invalid dt") else -> throw FatalAstException("invalid dt")
} }
} }
throw FatalAstException("cannot get indexed element on $target") return null
} }
override fun toString(): String { override fun toString(): String {

351
compiler/src/prog8/compiler/target/c64/AsmGen.kt
View File

@@ -768,15 +768,15 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
when(indexVar) { when(indexVar) {
"X" -> { "X" -> {
loadX = "" loadX = ""
loadXWord = " txa | asl a | tax |" loadXWord = " txa | asl a | tax |"
} }
"Y" -> { "Y" -> {
loadX = " tya | tax |" loadX = " tya | tax |"
loadXWord = " tya | asl a | tax |" loadXWord = " tya | asl a | tax |"
} }
"A" -> { "A" -> {
loadX = " tax |" loadX = " tax |"
loadXWord = " asl a | tax |" loadXWord = " asl a | tax |"
} }
else -> { else -> {
// the indexvar is a real variable, not a register // the indexvar is a real variable, not a register
@@ -912,6 +912,52 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
} }
} }
private fun loadAYFromWordIndexedByVar(idxVarInstr: Instruction, readArrayInstr: Instruction): String {
// AY = readWordArrayInstr [ idxVarInstr ]
return when(idxVarInstr.callLabel) {
"A" ->
"""
stx ${C64Zeropage.SCRATCH_B1}
asl a
tax
lda ${readArrayInstr.callLabel},x
ldy ${readArrayInstr.callLabel}+1,x
ldx ${C64Zeropage.SCRATCH_B1}
"""
"X" ->
"""
stx ${C64Zeropage.SCRATCH_B1}
txa
asl a
tax
lda ${readArrayInstr.callLabel},x
ldy ${readArrayInstr.callLabel}+1,x
ldx ${C64Zeropage.SCRATCH_B1}
"""
"Y" ->
"""
stx ${C64Zeropage.SCRATCH_B1}
tya
asl a
tax
lda ${readArrayInstr.callLabel},x
ldy ${readArrayInstr.callLabel}+1,x
ldx ${C64Zeropage.SCRATCH_B1}
"""
else ->
"""
stx ${C64Zeropage.SCRATCH_B1}
lda ${idxVarInstr.callLabel}
asl a
tax
lda ${readArrayInstr.callLabel},x
ldy ${readArrayInstr.callLabel}+1,x
ldx ${C64Zeropage.SCRATCH_B1}
"""
}
}
private fun storeAToIndexedByVar(idxVarInstr: Instruction, writeArrayInstr: Instruction): String { private fun storeAToIndexedByVar(idxVarInstr: Instruction, writeArrayInstr: Instruction): String {
// writeArrayInstr [ idxVarInstr ] = A // writeArrayInstr [ idxVarInstr ] = A
return when (idxVarInstr.callLabel) { return when (idxVarInstr.callLabel) {
@@ -924,20 +970,20 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
private val patterns = listOf( private val patterns = listOf(
// -------------- simple conversions ---------------- // -------------- simple conversions ----------------
// convert ubyte to uword // // convert ubyte to uword
AsmPattern(listOf(Opcode.UB2UWORD, Opcode.POP_VAR_WORD)) { // AsmPattern(listOf(Opcode.UB2UWORD, Opcode.POP_VAR_WORD)) {
" lda #0 | sta ${ESTACK_HI+1},x" // " lda #0 | sta ${ESTACK_HI+1},x"
}, // },
// convert byte to word (sign extended) // // convert byte to word (sign extended)
AsmPattern(listOf(Opcode.B2WORD, Opcode.POP_VAR_WORD)) { // AsmPattern(listOf(Opcode.B2WORD, Opcode.POP_VAR_WORD)) {
""" // """
lda ${ESTACK_LO+1},x // lda ${ESTACK_LO+1},x
ora #${'$'}7f // ora #${'$'}7f
bmi + // bmi +
lda #0 // lda #0
+ sta ${ESTACK_HI+1},x //+ sta ${ESTACK_HI+1},x
""" // """
}, // },
// ----------- push value from array on the stack ------------- // ----------- push value from array on the stack -------------
@@ -1280,11 +1326,50 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
val index = segment[0].arg!!.integerValue().toHex() val index = segment[0].arg!!.integerValue().toHex()
" lda ${segment[1].callLabel}+$index | sta ${segment[3].callLabel} | lda #0 | sta ${segment[3].callLabel}+1" " lda ${segment[1].callLabel}+$index | sta ${segment[3].callLabel} | lda #0 | sta ${segment[3].callLabel}+1"
}, },
// var = ubytearray[index var]
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.POP_VAR_WORD)) { segment ->
val loadA = loadAFromIndexedByVar(segment[0], segment[1])
" $loadA | sta ${segment[3].callLabel} | lda #0 | sta ${segment[3].callLabel}+1"
},
// var = ubytearray[index mem]
AsmPattern(
listOf(Opcode.PUSH_MEM_B, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.POP_VAR_WORD),
listOf(Opcode.PUSH_MEM_UB, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.POP_VAR_WORD)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${segment[3].callLabel}
lda #0
sta ${segment[3].callLabel}+1
"""
},
// var = (u)wordarray[index_byte] // var = (u)wordarray[index_byte]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD)) { segment -> AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
val index = segment[0].arg!!.integerValue()*2 val index = segment[0].arg!!.integerValue()*2
" lda ${segment[1].callLabel}+$index | sta ${segment[2].callLabel} | lda ${segment[1].callLabel}+${index+1} | sta ${segment[2].callLabel}+1" " lda ${segment[1].callLabel}+$index | sta ${segment[2].callLabel} | lda ${segment[1].callLabel}+${index+1} | sta ${segment[2].callLabel}+1"
}, },
// var = (u)wordarray[index var]
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
val loadAY = loadAYFromWordIndexedByVar(segment[0], segment[1])
"""
$loadAY
sta ${segment[2].callLabel}
sty ${segment[2].callLabel}+1
"""
},
// var = (u)wordarray[index mem]
AsmPattern(
listOf(Opcode.PUSH_MEM_B, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD),
listOf(Opcode.PUSH_MEM_UB, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[1].callLabel},y
sta ${segment[2].callLabel}
lda ${segment[1].callLabel}+1,y
sta ${segment[2].callLabel}+1
"""
},
// mem = (u)word value // mem = (u)word value
AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.POP_MEM_WORD)) { segment -> AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.POP_MEM_WORD)) { segment ->
""" """
@@ -1429,6 +1514,49 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
sty ${segment[2].callLabel}+${index+1} sty ${segment[2].callLabel}+${index+1}
""" """
}, },
// uwordarray[index mem] = (u)word value
AsmPattern(
listOf(Opcode.PUSH_WORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_WORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val value = segment[0].arg!!.integerValue().toHex()
"""
lda ${segment[1].arg!!.integerValue().toHex()}
asl a
tay
lda #<$value
sta ${segment[2].callLabel},y
lda #>$value
sta ${segment[2].callLabel}+1,y
"""
},
// uwordarray[index mem] = mem (u)word
AsmPattern(
listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
"""
lda ${segment[1].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${segment[2].callLabel},y
lda ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${segment[2].callLabel}+1,y
"""
},
// uwordarray[index mem] = (u)word var
AsmPattern(
listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
"""
lda ${segment[1].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[0].callLabel}
sta ${segment[2].callLabel},y
lda ${segment[0].callLabel}+1
sta ${segment[2].callLabel}+1,y
"""
},
// uwordarray[index] = ubytevar // uwordarray[index] = ubytevar
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment -> AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val index = segment[2].arg!!.integerValue()*2 val index = segment[2].arg!!.integerValue()*2
@@ -1436,9 +1564,73 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
"A" -> " sta ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}" "A" -> " sta ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}"
"X" -> " stx ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}" "X" -> " stx ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}"
"Y" -> " sty ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}" "Y" -> " sty ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}"
else -> " lda ${segment[0].callLabel} | sta ${segment[2].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}" else -> " lda ${segment[0].callLabel} | sta ${segment[3].callLabel}+$index | lda #0 | sta ${segment[3].callLabel}+${index+1}"
} }
}, },
// uwordarray[index mem] = ubytevar
AsmPattern(
listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
when(segment[0].callLabel) {
"A" ->
"""
pha
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
tay
pla
sta ${segment[3].callLabel},y
lda #0
sta ${segment[3].callLabel}+1,y
"""
"X" ->
"""
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
tay
txa
sta ${segment[3].callLabel},y
lda #0
sta ${segment[3].callLabel}+1,y
"""
"Y" ->
"""
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
stx ${C64Zeropage.SCRATCH_B1}
tax
tya
sta ${segment[3].callLabel},x
lda #0
sta ${segment[3].callLabel}+1,x
ldx ${C64Zeropage.SCRATCH_B1}
"""
else ->
"""
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[0].callLabel}
sta ${segment[3].callLabel},y
lda #0
sta ${segment[3].callLabel}+1,y
"""
}
},
// uwordarray[index mem] = ubyte mem
AsmPattern(
listOf(Opcode.PUSH_MEM_UB, Opcode.UB2UWORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_MEM_UB, Opcode.UB2UWORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
"""
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${segment[3].callLabel},y
lda #0
sta ${segment[3].callLabel}+1,y
"""
},
// uwordarray[index] = mem ubyte // uwordarray[index] = mem ubyte
AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2UWORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment -> AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2UWORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val index = segment[2].arg!!.integerValue()*2 val index = segment[2].arg!!.integerValue()*2
@@ -1460,8 +1652,8 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
""" """
lda ${segment[0].arg!!.integerValue().toHex()} lda ${segment[0].arg!!.integerValue().toHex()}
ldy ${(segment[0].arg!!.integerValue()+1).toHex()} ldy ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${segment[3].callLabel}+$index sta ${segment[2].callLabel}+$index
sty ${segment[3].callLabel}+${index+1} sty ${segment[2].callLabel}+${index+1}
""" """
}, },
// uwordarray2[index2] = ubytearray1[index1] // uwordarray2[index2] = ubytearray1[index1]
@@ -1486,25 +1678,113 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
sta ${segment[3].callLabel}+${index2+1} sta ${segment[3].callLabel}+${index2+1}
""" """
}, },
// uwordarray[indexvar]v = (u)word value // uwordarray[indexvar] = (u)word value
AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment -> AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val value = segment[0].arg!!.integerValue().toHex() val value = segment[0].arg!!.integerValue().toHex()
val store = when(segment[1].callLabel) { val loadIndexY = when(segment[1].callLabel) {
"A" -> { "A" -> " asl a | tay"
TODO("$segment") "X" -> " txa | asl a | tay"
} "Y" -> " tya | asl a | tay"
"X" -> { else -> " lda ${segment[1].callLabel} | asl a | tay"
TODO("$segment")
}
"Y" -> {
TODO("$segment")
}
else -> {
TODO("$segment")
}
} }
" $loadIndexY | lda #<$value | sta ${segment[2].callLabel},y | lda #>$value | sta ${segment[2].callLabel}+1,y"
},
// uwordarray[indexvar] = ubyte var
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val loadValueOnStack = when(segment[0].callLabel) {
"A" -> " pha"
"X" -> " txa | pha"
"Y" -> " tya | pha"
else -> " lda ${segment[0].callLabel} | pha"
}
val loadIndexY = when(segment[2].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[2].callLabel} | asl a | tay"
}
" $loadValueOnStack | $loadIndexY | pla | sta ${segment[3].callLabel},y | lda #0 | sta ${segment[3].callLabel}+1,y"
},
// uwordarray[indexvar] = uword var
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val loadIndexY = when(segment[1].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[1].callLabel} | asl a | tay"
}
" $loadIndexY | lda ${segment[0].callLabel} | sta ${segment[2].callLabel},y | lda ${segment[0].callLabel}+1 | sta ${segment[2].callLabel}+1,y"
},
// uwordarray[indexvar] = mem ubyte
AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2UWORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val loadIndexY = when(segment[2].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[2].callLabel} | asl a | tay"
}
" $loadIndexY | lda ${segment[0].arg!!.integerValue().toHex()} | sta ${segment[3].callLabel},y | lda #0 | sta ${segment[3].callLabel}+1,y"
},
// uwordarray[indexvar] = mem uword
AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
val loadIndexY = when(segment[1].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[1].callLabel} | asl a | tay"
}
" $loadIndexY | lda ${segment[0].arg!!.integerValue().toHex()} | sta ${segment[2].callLabel},y | lda ${(segment[0].arg!!.integerValue()+1).toHex()} | sta ${segment[2].callLabel}+1,y"
},
// uwordarray2[indexvar] = ubytearay[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment->
val index = segment[0].arg!!.integerValue()
val loadIndex2Y = when(segment[3].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[3].callLabel} | asl a | tay"
}
" $loadIndex2Y | lda ${segment[1].callLabel}+$index | sta ${segment[4].callLabel},y | lda #0 | sta ${segment[4].callLabel}+1,y"
},
// uwordarray2[indexvar] = uwordarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment->
val index = segment[0].arg!!.integerValue()*2
val loadIndex2Y = when(segment[2].callLabel) {
"A" -> " asl a | tay"
"X" -> " txa | asl a | tay"
"Y" -> " tya | asl a | tay"
else -> " lda ${segment[2].callLabel} | asl a | tay"
}
" $loadIndex2Y | lda ${segment[1].callLabel}+$index | sta ${segment[3].callLabel},y | lda ${segment[1].callLabel}+${index+1} | sta ${segment[3].callLabel}+1,y"
},
// uwordarray2[index mem] = ubytearray1[index1]
AsmPattern(
listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment->
val index1 = segment[0].arg!!.integerValue()
""" """
lda ${segment[3].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[1].callLabel}+$index1
sta ${segment[4].callLabel},y
lda #0
sta ${segment[4].callLabel}+1,y
"""
},
// uwordarray2[index mem] = uwordarray1[index1]
AsmPattern(
listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_MEM_B, Opcode.WRITE_INDEXED_VAR_WORD),
listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_MEM_UB, Opcode.WRITE_INDEXED_VAR_WORD)) { segment->
val index1 = segment[0].arg!!.integerValue()
"""
lda ${segment[2].arg!!.integerValue().toHex()}
asl a
tay
lda ${segment[1].callLabel}+$index1
sta ${segment[3].callLabel},y
lda ${segment[1].callLabel}+${index1+1}
sta ${segment[3].callLabel}+1,y
""" """
}, },
@@ -1952,4 +2232,5 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
// } // }
) )
} }