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

assignments

Browse Source
This commit is contained in:
Irmen de Jong 2018-11-01 23:42:10 +01:00
parent a550e2b413
commit 4ef680f6fd
7 changed files with 911 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
compiler/examples/test.p8
View File

@ -224,6 +224,37 @@ ubyte_assignment_to_ubytearray:
string[ub2] = string[mbyte2]
string[ub2] = string[mubyte2]
ubarr2[b2] = 42
ubarr2[b2] = X
ubarr2[b2] = ub2
ubarr2[b2] = mubyte2
ubarr2[b2] = string[4]
ubarr2[b2] = string[X]
ubarr2[b2] = string[b]
ubarr2[b2] = string[ub]
ubarr2[b2] = string[mbyte2]
ubarr2[b2] = string[mubyte2]
ubarr2[b2] = ubarr1[2]
ubarr2[b2] = ubarr1[X]
ubarr2[b2] = ubarr1[b]
ubarr2[b2] = ubarr1[ub]
ubarr2[b2] = ubarr1[mbyte2]
ubarr2[b2] = ubarr1[mubyte2]
string[b2] = 42
string[b2] = 'B'
string[b2] = X
string[b2] = ub2
string[b2] = mubyte2
string[b2] = ubarr1[2]
string[b2] = ubarr1[Y]
string[b2] = ubarr1[ub2]
string[b2] = ubarr1[mubyte2]
string[b2] = string[Y]
string[b2] = string[ub2]
string[b2] = string[mbyte2]
string[b2] = string[mubyte2]
ubarr2[mubyte2] = 42
ubarr2[mubyte2] = X
ubarr2[mubyte2] = ub2
@ -280,6 +311,16 @@ byte_assignment_to_bytearray:
barr2[Y] = barr1[mbyte2]
barr2[Y] = barr1[mubyte2]
barr2[b2] = 42
barr2[b2] = b2
barr2[b2] = mbyte2
barr2[b2] = barr1[2]
barr2[b2] = barr1[X]
barr2[b2] = barr1[b]
barr2[b2] = barr1[ub]
barr2[b2] = barr1[mbyte2]
barr2[b2] = barr1[mubyte2]
barr2[ub2] = 42
barr2[ub2] = b2
barr2[ub2] = mbyte2
@ -402,6 +443,102 @@ uword_assignment_to_uwordmem:
; muword = uwarr1[mubyte2] ; todo via evaluation
uword_assignment_to_uwordarray:
uwarr1[2] = 42
uwarr1[2] = 42.w
uwarr1[2] = 42555
uwarr1[2] = X
uwarr1[2] = XY
uwarr1[2] = ub2
uwarr1[2] = uw2
uwarr1[2] = mubyte2
uwarr1[2] = muword2
uwarr1[2] = string[4]
uwarr1[2] = ubarr1[2]
uwarr1[2] = uwarr1[2]
uwarr1[Y] = 42
uwarr1[Y] = 42.w
uwarr1[Y] = 42555
uwarr1[Y] = X
uwarr1[Y] = XY
uwarr1[Y] = ub2
uwarr1[Y] = uw2
uwarr1[Y] = mubyte2
uwarr1[Y] = muword2
uwarr1[Y] = string[4]
uwarr1[Y] = ubarr1[2]
uwarr1[Y] = uwarr1[2]
uwarr1[b] = 42
uwarr1[b] = 42.w
uwarr1[b] = 42555
uwarr1[b] = X
uwarr1[b] = XY
uwarr1[b] = ub2
uwarr1[b] = uw2
uwarr1[b] = mubyte2
uwarr1[b] = muword2
uwarr1[b] = string[4]
uwarr1[b] = ubarr1[2]
uwarr1[b] = uwarr1[2]
uwarr1[ub] = 42
uwarr1[ub] = 42.w
uwarr1[ub] = 42555
uwarr1[ub] = X
uwarr1[ub] = XY
uwarr1[ub] = ub2
uwarr1[ub] = uw2
uwarr1[ub] = mubyte2
uwarr1[ub] = muword2
uwarr1[ub] = string[4]
uwarr1[ub] = ubarr1[2]
uwarr1[ub] = uwarr1[2]
uwarr1[mbyte2] = 42
uwarr1[mbyte2] = 42.w
uwarr1[mbyte2] = 42555
uwarr1[mbyte2] = X
uwarr1[mbyte2] = XY
uwarr1[mbyte2] = ub2
uwarr1[mbyte2] = uw2
uwarr1[mbyte2] = mubyte2
uwarr1[mbyte2] = muword2
uwarr1[mbyte2] = string[4]
uwarr1[mbyte2] = ubarr1[2]
uwarr1[mbyte2] = uwarr1[2]
uwarr1[mubyte2] = 42
uwarr1[mubyte2] = 42.w
uwarr1[mubyte2] = 42555
uwarr1[mubyte2] = X
uwarr1[mubyte2] = XY
uwarr1[mubyte2] = ub2
uwarr1[mubyte2] = uw2
uwarr1[mubyte2] = mubyte2
uwarr1[mubyte2] = muword2
uwarr1[mubyte2] = string[4]
uwarr1[mubyte2] = ubarr1[2]
uwarr1[mubyte2] = uwarr1[2]
; uwarr1[2] = string[X] ; todo via evaluation
; uwarr1[2] = string[b] ; todo via evaluation
; uwarr1[2] = string[ub] ; todo via evaluation
; uwarr1[2] = string[mbyte2] ; todo via evaluation
; uwarr1[2] = string[mubyte2] ; todo via evaluation
; uwarr1[2] = ubarr1[X] ; todo via evaluation
; uwarr1[2] = ubarr1[b] ; todo via evaluation
; uwarr1[2] = ubarr1[ub] ; todo via evaluation
; uwarr1[2] = ubarr1[mbyte2] ; todo via evaluation
; uwarr1[2] = ubarr1[mubyte2] ; todo via evaluation
; uwarr1[2] = uwarr1[X] ; todo via evaluation
; uwarr1[2] = uwarr1[b] ; todo via evaluation
; uwarr1[2] = uwarr1[ub] ; todo via evaluation
; uwarr1[2] = uwarr1[mbyte2] ; todo via evaluation
; uwarr1[2] = uwarr1[mubyte2] ; todo via evaluation
word_assignment_to_wordvar:
w = -42
@ -418,46 +555,158 @@ word_assignment_to_wordvar:
w = ubarr1[2]
w = barr1[2]
w = warr1[2]
;uw = string[X] ; todo via evaluation
;uw = string[b] ; todo via evaluation
;uw = string[ub] ; todo via evaluation
;uw = string[mbyte2] ; todo via evaluation
;uw = string[mubyte2] ; todo via evaluation
; uw = ubarr1[X] ;; todo via evaluation
; uw = ubarr1[b] ;; todo via evaluation
; uw = ubarr1[ub] ; todo via evaluation
; uw = ubarr1[mbyte2] ; todo via evaluation
; uw = ubarr1[mubyte2] ; todo via evaluation
; uw = uwarr1[X] ; todo via evaluation
; uw = uwarr1[b] ; todo via evaluation
; uw = uwarr1[ub] ; todo via evaluation
; uw = uwarr1[mbyte2] ; todo via evaluation
; uw = uwarr1[mubyte2] ; todo via evaluation
; w = string[X] ; todo via evaluation
; w = string[b] ; todo via evaluation
; w = string[ub] ; todo via evaluation
; w = string[mbyte2] ; todo via evaluation
; w = string[mubyte2] ; todo via evaluation
; w = barr1[X] ;; todo via evaluation
; w = ubarr1[X] ;; todo via evaluation
; w = barr1[b] ;; todo via evaluation
; w = ubarr1[b] ;; todo via evaluation
; w = barr1[ub] ; todo via evaluation
; w = ubarr1[ub] ; todo via evaluation
; w = barr1[mbyte2] ; todo via evaluation
; w = ubarr1[mbyte2] ; todo via evaluation
; w = barr1[mubyte2] ; todo via evaluation
; w = ubarr1[mubyte2] ; todo via evaluation
; w = warr1[X] ; todo via evaluation
; w = warr1[b] ; todo via evaluation
; w = warr1[ub] ; todo via evaluation
; w = warr1[mbyte2] ; todo via evaluation
; w = warr1[mubyte2] ; todo via evaluation
word_assignment_to_wordmem:
mword = -42
mword = -42.w
mword = 12555
mword = X
mword = ub2
mword = b2
mword = w2
mword = mubyte2
mword = mbyte2
mword = mword2
mword = string[4]
mword = ubarr1[2]
mword = barr1[2]
mword = warr1[2]
; mword = string[X] ; todo via evaluation
; mword = string[b] ; todo via evaluation
; mword = string[ub] ; todo via evaluation
; mword = string[mbyte2] ; todo via evaluation
; mword = string[mubyte2] ; todo via evaluation
; mword = barr1[X] ;; todo via evaluation
; mword = ubarr1[X] ;; todo via evaluation
; mword = barr1[b] ;; todo via evaluation
; mword = ubarr1[b] ;; todo via evaluation
; mword = barr1[ub] ; todo via evaluation
; mword = ubarr1[ub] ; todo via evaluation
; mword = barr1[mbyte2] ; todo via evaluation
; mword = ubarr1[mbyte2] ; todo via evaluation
; mword = barr1[mubyte2] ; todo via evaluation
; mword = ubarr1[mubyte2] ; todo via evaluation
; mword = warr1[X] ; todo via evaluation
; mword = warr1[b] ; todo via evaluation
; mword = warr1[ub] ; todo via evaluation
; mword = warr1[mbyte2] ; todo via evaluation
; mword = warr1[mubyte2] ; todo via evaluation
;; all possible assignments to a FLOAT VARIABLE
;float_assignment_to_floatvar:
; fl1 = 34
; fl1 = 34555.w
; fl1 = 3.33e22
; fl1 = X
; fl1 = AY
; fl1 = b2
; fl1 = ub2
; fl1 = w2
; fl1 = uw2
; fl1 = mbyte
; fl1 = mubyte
; fl1 = mword
; fl1 = muword
; fl1 = barr1[2]
; fl1 = ubarr1[2]
; fl1 = warr1[2]
; fl1 = uwarr1[2]
; fl1 = string[4]
float_assignment_to_floatvar:
fl1 = 34
fl1 = 34555.w
fl1 = 3.33e22
fl1 = X
fl1 = AY
fl1 = b2
fl1 = ub2
fl1 = w2
fl1 = uw2
fl1 = mbyte
fl1 = mubyte
fl1 = mword
fl1 = muword
fl1 = fl2
fl1 = mfloat2
fl1 = barr1[2]
fl1 = ubarr1[2]
fl1 = warr1[2]
fl1 = uwarr1[2]
fl1 = string[4]
fl1 = farr1[4]
; fl1 = string[X] ; todo via evaluation
; fl1 = string[b] ; todo via evaluation
; fl1 = string[ub] ; todo via evaluation
; fl1 = string[mbyte2] ; todo via evaluation
; fl1 = string[mubyte2] ; todo via evaluation
; fl1 = barr1[X] ;; todo via evaluation
; fl1 = ubarr1[X] ;; todo via evaluation
; fl1 = barr1[b] ;; todo via evaluation
; fl1 = ubarr1[b] ;; todo via evaluation
; fl1 = barr1[ub] ; todo via evaluation
; fl1 = ubarr1[ub] ; todo via evaluation
; fl1 = barr1[mbyte2] ; todo via evaluation
; fl1 = ubarr1[mbyte2] ; todo via evaluation
; fl1 = barr1[mubyte2] ; todo via evaluation
; fl1 = ubarr1[mubyte2] ; todo via evaluation
; fl1 = warr1[X] ; todo via evaluation
; fl1 = warr1[b] ; todo via evaluation
; fl1 = warr1[ub] ; todo via evaluation
; fl1 = warr1[mbyte2] ; todo via evaluation
; fl1 = warr1[mubyte2] ; todo via evaluation
float_assignment_to_floatmem:
mfloat = 34
mfloat = 34555.w
mfloat = 3.33e22
mfloat = X
mfloat = AY
mfloat = b2
mfloat = ub2
mfloat = w2
mfloat = uw2
mfloat = mbyte
mfloat = mubyte
mfloat = mword
mfloat = muword
mfloat = fl2
mfloat = mfloat2
mfloat = barr1[2]
mfloat = ubarr1[2]
mfloat = warr1[2]
mfloat = uwarr1[2]
mfloat = string[4]
mfloat = farr1[4]
; mfloat = string[X] ; todo via evaluation
; mfloat = string[b] ; todo via evaluation
; mfloat = string[ub] ; todo via evaluation
; mfloat = string[mbyte2] ; todo via evaluation
; mfloat = string[mubyte2] ; todo via evaluation
; mfloat = barr1[X] ;; todo via evaluation
; mfloat = ubarr1[X] ;; todo via evaluation
; mfloat = barr1[b] ;; todo via evaluation
; mfloat = ubarr1[b] ;; todo via evaluation
; mfloat = barr1[ub] ; todo via evaluation
; mfloat = ubarr1[ub] ; todo via evaluation
; mfloat = barr1[mbyte2] ; todo via evaluation
; mfloat = ubarr1[mbyte2] ; todo via evaluation
; mfloat = barr1[mubyte2] ; todo via evaluation
; mfloat = ubarr1[mubyte2] ; todo via evaluation
; mfloat = warr1[X] ; todo via evaluation
; mfloat = warr1[b] ; todo via evaluation
; mfloat = warr1[ub] ; todo via evaluation
; mfloat = warr1[mbyte2] ; todo via evaluation
; mfloat = warr1[mubyte2] ; todo via evaluation
return
}

8
compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt
View File

@ -147,7 +147,6 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
Opcode.MSB,
Opcode.B2WORD,
Opcode.UB2UWORD,
Opcode.MSB2WORD,
Opcode.B2FLOAT,
Opcode.UB2FLOAT,
Opcode.UW2FLOAT,
@ -175,7 +174,6 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
}
Opcode.B2WORD,
Opcode.UB2UWORD,
Opcode.MSB2WORD,
Opcode.B2FLOAT,
Opcode.UB2FLOAT -> throw CompilerException("invalid conversion following a word")
Opcode.W2FLOAT, Opcode.UW2FLOAT -> {
@ -206,11 +204,6 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
instructionsToReplace[index0] = ins
instructionsToReplace[index1] = Instruction(Opcode.NOP)
}
Opcode.MSB2WORD -> {
val ins = Instruction(Opcode.PUSH_WORD, Value(DataType.UWORD, 256 * ins0.arg!!.integerValue()))
instructionsToReplace[index0] = ins
instructionsToReplace[index1] = Instruction(Opcode.NOP)
}
Opcode.B2FLOAT, Opcode.UB2FLOAT -> {
val ins = Instruction(Opcode.PUSH_FLOAT, Value(DataType.FLOAT, ins0.arg!!.integerValue().toDouble()))
instructionsToReplace[index0] = ins
@ -234,7 +227,6 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
Opcode.MSB,
Opcode.B2WORD,
Opcode.UB2UWORD,
Opcode.MSB2WORD,
Opcode.B2FLOAT,
Opcode.UB2FLOAT,
Opcode.W2FLOAT,

1
compiler/src/prog8/compiler/intermediate/Opcode.kt
View File

@ -119,7 +119,6 @@ enum class Opcode {
UB2B,
B2WORD, // convert a byte into a word where it is the lower eight bits $ssxx with sign extension
UB2UWORD, // convert a byte into a word where it is the lower eight bits $00xx
MSB2WORD, // convert a byte into a word where it is the upper eight bits $xx00
B2FLOAT, // convert byte into floating point
UB2FLOAT, // convert unsigned byte into floating point
W2FLOAT, // convert word into floating point

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

@ -11,7 +11,6 @@ import prog8.compiler.intermediate.*
import prog8.stackvm.Syscall
import prog8.stackvm.syscallsForStackVm
import java.io.File
import java.io.PrintWriter
import java.util.*
import kotlin.math.abs
@ -975,6 +974,23 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
}
private val patterns = listOf(
// -------------- simple conversions ----------------
// convert ubyte to uword
AsmPattern(listOf(Opcode.UB2UWORD, Opcode.POP_VAR_WORD)) {
" lda #0 | sta ${ESTACK_HI+1},x"
},
// convert byte to word (sign extended)
AsmPattern(listOf(Opcode.B2WORD, Opcode.POP_VAR_WORD)) {
"""
lda ${ESTACK_LO+1},x
ora #${'$'}7f
bmi +
lda #0
+ sta ${ESTACK_HI+1},x
"""
},
// ----------- push value from array on the stack -------------
// // push: array[variable]
// AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE)) { segment ->
@ -1434,8 +1450,10 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
else -> " lda ${segment[0].callLabel} || sta ${segment[1].arg!!.integerValue().toHex()} | lda ${segment[0].callLabel}+1 | sta ${(segment[1].arg!!.integerValue()+1).toHex()}"
}
},
// mem uword = mem uword
AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.POP_MEM_WORD)) { segment ->
// mem (u)word = mem (u)word
AsmPattern(
listOf(Opcode.PUSH_MEM_UW, Opcode.POP_MEM_WORD),
listOf(Opcode.PUSH_MEM_W, Opcode.POP_MEM_WORD)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
ldy ${(segment[0].arg!!.integerValue()+1).toHex()}
@ -1447,15 +1465,93 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.POP_MEM_WORD)) { segment ->
val index = segment[0].arg!!.integerValue()
when(segment[1].callLabel) {
"AX" -> " sta ${C64Zeropage.SCRATCH_W1} | stx ${C64Zeropage.SCRATCH_W1+1} | ldy #$index | lda (${C64Zeropage.SCRATCH_W1}),y | sta ${segment[3].arg!!.integerValue().toHex()} | lda #0 | sta ${(segment[3].arg!!.integerValue()+1).toHex()}"
"AY" -> " sta ${C64Zeropage.SCRATCH_W1} | sty ${C64Zeropage.SCRATCH_W1+1} | ldy #$index | lda (${C64Zeropage.SCRATCH_W1}),y | sta ${segment[3].arg!!.integerValue().toHex()} | lda #0 | sta ${(segment[3].arg!!.integerValue()+1).toHex()}"
"XY" -> " stx ${C64Zeropage.SCRATCH_W1} | sty ${C64Zeropage.SCRATCH_W1+1} | ldy #$index | lda (${C64Zeropage.SCRATCH_W1}),y | sta ${segment[3].arg!!.integerValue().toHex()} | lda #0 | sta ${(segment[3].arg!!.integerValue()+1).toHex()}"
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
lda #0
sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
lda #0
sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
lda #0
sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
else ->
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${segment[3].arg!!.integerValue().toHex()}
sty ${(segment[3].arg!!.integerValue()+1).toHex()}
lda #0
sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
}
},
// mem uword = bytearray[index] (sign extended)
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.B2WORD, Opcode.POP_MEM_WORD)) { segment ->
val index = segment[0].arg!!.integerValue()
when(segment[1].callLabel) {
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
ora #${'$'}7f
bmi +
lda #0
+ sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
ora #${'$'}7f
bmi +
lda #0
+ sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
ldy #$index
lda (${C64Zeropage.SCRATCH_W1}),y
sta ${segment[3].arg!!.integerValue().toHex()}
ora #${'$'}7f
bmi +
lda #0
+ sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
else ->
"""
lda ${segment[1].callLabel}+$index
sta ${segment[3].arg!!.integerValue().toHex()}
ora #${'$'}7f
bmi +
lda #0
+ sta ${(segment[3].arg!!.integerValue()+1).toHex()}
"""
}
},
@ -1480,6 +1576,28 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
+ sta ${segment[2].callLabel}+1
"""
},
// mem word = bytevar (sign extended)
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.B2WORD, Opcode.POP_MEM_WORD)) { segment ->
"""
lda ${segment[0].callLabel}
sta ${segment[2].arg!!.integerValue().toHex()}
ora #$7f
bmi +
lda #0
+ sta ${(segment[2].arg!!.integerValue()+1).toHex()}
"""
},
// mem word = mem byte (sign extended)
AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.B2WORD, Opcode.POP_MEM_WORD)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${segment[2].arg!!.integerValue().toHex()}
ora #$7f
bmi +
lda #0
+ sta ${(segment[2].arg!!.integerValue()+1).toHex()}
"""
},
// var = membyte (sign extended)
AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.B2WORD, Opcode.POP_VAR_WORD)) { segment ->
"""
@ -1494,22 +1612,128 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
// var = bytearray[index_byte] (sign extended)
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.B2WORD, Opcode.POP_VAR_WORD)) { segment ->
val index = segment[0].arg!!.integerValue().toHex()
TODO("$segment (sign extended)")
"""
lda ${segment[1].callLabel}+$index
sta ${segment[3].callLabel}
ora #${'$'}7f
bmi +
lda #0
+ sta ${segment[3].callLabel}+1
"""
},
// // var = bytearray[indexvar] (sign extended) VIA REGULAR STACK EVALUATION: Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2UWORD, Opcode.POP_VAR_WORD
// // TODO: UB2UWORD + POP_VAR_WORD special pattern?
// // var = (u)wordarray[indexvar] VIA REGULAR STACK EVALUATION: Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.POP_VAR_WORD
// ----------- assignment to FLOAT VARIABLE ----------------
// floatvar = ubytevar
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val loadByteA = when(segment[0].callLabel) {
"A" -> ""
"X" -> "txa"
"Y" -> "tya"
else -> "lda ${segment[0].callLabel}"
}
"""
$loadByteA
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.ub2float
"""
},
// floatvar = uwordvar
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.UW2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
when (segment[0].callLabel) {
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.uw2float
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.uw2float
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.uw2float
"""
else ->
"""
lda ${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
lda ${segment[0].callLabel}+1
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.uw2float
"""
}
},
// floatvar = bytevar
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.B2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val loadByteA = when(segment[0].callLabel) {
"A" -> ""
"X" -> "txa"
"Y" -> "tya"
else -> "lda ${segment[0].callLabel}"
}
"""
$loadByteA
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.b2float
"""
},
// floatvar = wordvar
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.W2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
when (segment[0].callLabel) {
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.w2float
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.w2float
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.w2float
"""
else ->
"""
lda ${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
lda ${segment[0].callLabel}+1
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.w2float
"""
}
},
// floatvar = float value
AsmPattern(listOf(Opcode.PUSH_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
val floatConst = getFloatConst(segment[0].arg!!)
@ -1522,214 +1746,391 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
ldy #>${segment[1].callLabel}
jsr prog8_lib.copy_float
"""
},
// floatvar = float var
AsmPattern(listOf(Opcode.PUSH_VAR_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
"""
lda #<${segment[0].callLabel}
ldy #>${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[1].callLabel}
ldy #>${segment[1].callLabel}
jsr prog8_lib.copy_float
"""
},
// floatvar = mem float
AsmPattern(listOf(Opcode.PUSH_MEM_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
"""
lda #<${segment[0].arg!!.integerValue().toHex()}
ldy #>${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[1].callLabel}
ldy #>${segment[1].callLabel}
jsr prog8_lib.copy_float
"""
},
// floatvar = mem byte
AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.B2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.b2float
"""
},
// floatvar = mem ubyte
AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.ub2float
"""
},
// floatvar = mem word
AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.W2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
lda ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.w2float
"""
},
// floatvar = mem uword
AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.UW2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
lda ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.uw2float
"""
},
// floatvar = bytearray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.B2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()
"""
lda ${segment[1].callLabel}+$index
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[3].callLabel}
ldy #>${segment[3].callLabel}
jsr prog8_lib.b2float
"""
},
// floatvar = ubytearray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()
"""
lda ${segment[1].callLabel}+$index
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[3].callLabel}
ldy #>${segment[3].callLabel}
jsr prog8_lib.ub2float
"""
},
// floatvar = wordarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.W2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()*2
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[3].callLabel}
ldy #>${segment[3].callLabel}
jsr prog8_lib.w2float
"""
},
// floatvar = uwordarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.UW2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()*2
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[3].callLabel}
ldy #>${segment[3].callLabel}
jsr prog8_lib.uw2float
"""
},
// floatvar = floatarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
val index = segment[0].arg!!.integerValue() * Mflpt5.MemorySize
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].callLabel}
ldy #>${segment[2].callLabel}
jsr prog8_lib.copy_float
"""
},
// memfloat = float value
AsmPattern(listOf(Opcode.PUSH_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
val floatConst = getFloatConst(segment[0].arg!!)
"""
lda #<$floatConst
ldy #>$floatConst
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[1].arg!!.integerValue().toHex()}
ldy #>${segment[1].arg!!.integerValue().toHex()}
jsr prog8_lib.copy_float
"""
},
// memfloat = float var
AsmPattern(listOf(Opcode.PUSH_VAR_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
"""
lda #<${segment[0].callLabel}
ldy #>${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[1].arg!!.integerValue().toHex()}
ldy #>${segment[1].arg!!.integerValue().toHex()}
jsr prog8_lib.copy_float
"""
},
// memfloat = ubytevar
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val loadByteA = when(segment[0].callLabel) {
"A" -> ""
"X" -> "txa"
"Y" -> "tya"
else -> "lda ${segment[0].callLabel}"
}
"""
$loadByteA
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.ub2float
"""
},
// memfloat = uwordvar
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.UW2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
when (segment[0].callLabel) {
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
else ->
"""
lda ${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
lda ${segment[0].callLabel}+1
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
}
},
// memfloat = bytevar
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.B2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val loadByteA = when(segment[0].callLabel) {
"A" -> ""
"X" -> "txa"
"Y" -> "tya"
else -> "lda ${segment[0].callLabel}"
}
"""
$loadByteA
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.b2float
"""
},
// memfloat = wordvar
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.W2FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
when (segment[0].callLabel) {
"AX" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
stx ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
"AY" ->
"""
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
"XY" ->
"""
stx ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
else ->
"""
lda ${segment[0].callLabel}
sta ${C64Zeropage.SCRATCH_W1}
lda ${segment[0].callLabel}+1
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
}
},
// memfloat = mem byte
AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.B2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.b2float
"""
},
// memfloat = mem ubyte
AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.ub2float
"""
},
// memfloat = mem word
AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.W2FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
lda ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
},
// memfloat = mem uword
AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.UW2FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
"""
lda ${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
lda ${(segment[0].arg!!.integerValue()+1).toHex()}
sta ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
},
// memfloat = mem float
AsmPattern(listOf(Opcode.PUSH_MEM_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
"""
lda #<${segment[0].arg!!.integerValue().toHex()}
ldy #>${segment[0].arg!!.integerValue().toHex()}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[1].arg!!.integerValue().toHex()}
ldy #>${segment[1].arg!!.integerValue().toHex()}
jsr prog8_lib.copy_float
"""
},
// memfloat = bytearray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.B2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()
"""
lda ${segment[1].callLabel}+$index
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[3].arg!!.integerValue().toHex()}
ldy #>${segment[3].arg!!.integerValue().toHex()}
jsr prog8_lib.b2float
"""
},
// memfloat = ubytearray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.UB2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()
"""
lda ${segment[1].callLabel}+$index
sta ${C64Zeropage.SCRATCH_B1}
lda #<${segment[3].arg!!.integerValue().toHex()}
ldy #>${segment[3].arg!!.integerValue().toHex()}
jsr prog8_lib.ub2float
"""
},
// memfloat = wordarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.W2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()*2
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[3].arg!!.integerValue().toHex()}
ldy #>${segment[3].arg!!.integerValue().toHex()}
jsr prog8_lib.w2float
"""
},
// memfloat = uwordarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.UW2FLOAT, Opcode.POP_MEM_FLOAT)) { segment->
val index = segment[0].arg!!.integerValue()*2
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[3].arg!!.integerValue().toHex()}
ldy #>${segment[3].arg!!.integerValue().toHex()}
jsr prog8_lib.uw2float
"""
},
// memfloat = floatarray[index]
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
val index = segment[0].arg!!.integerValue() * Mflpt5.MemorySize
"""
lda ${segment[1].callLabel}+$index
ldy ${segment[1].callLabel}+${index+1}
sta ${C64Zeropage.SCRATCH_W1}
sty ${C64Zeropage.SCRATCH_W1+1}
lda #<${segment[2].arg!!.integerValue().toHex()}
ldy #>${segment[2].arg!!.integerValue().toHex()}
jsr prog8_lib.copy_float
"""
}
// // floatvar = mem float
// AsmPattern(listOf(Opcode.PUSH_MEM_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
// """
// lda #<${segment[0].arg!!.integerValue().toHex()}
// ldy #>${segment[0].arg!!.integerValue().toHex()}
// sta ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[1].callLabel}
// ldy #>${segment[1].callLabel}
// jsr prog8_lib.copy_float
// """
// },
// // floatvar = ubytevar
// AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.UB2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
// val loadByteA = when(segment[0].callLabel) {
// "A" -> ""
// "X" -> "txa"
// "Y" -> "tya"
// else -> "lda ${segment[0].callLabel}"
// }
// """
// $loadByteA
// sta ${C64Zeropage.SCRATCH_B1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.ub2float
// """
// },
// // floatvar = bytevar
// AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.B2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
// val loadByteA = when(segment[0].callLabel) {
// "A" -> ""
// "X" -> "txa"
// "Y" -> "tya"
// else -> "lda ${segment[0].callLabel}"
// }
// """
// $loadByteA
// sta ${C64Zeropage.SCRATCH_B1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.b2float
// """
// },
// // floatvar = uwordvar
// AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.UW2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
// when (segment[0].callLabel) {
// "AX" ->
// """
// sta ${C64Zeropage.SCRATCH_W1}
// stx ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.uw2float
// """
// "AY" ->
// """
// sta ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.uw2float
// """
// "XY" ->
// """
// stx ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.uw2float
// """
// else ->
// """
// lda ${segment[0].callLabel}
// sta ${C64Zeropage.SCRATCH_W1}
// lda ${segment[0].callLabel}+1
// sta ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.uw2float
// """
// }
// },
// // floatvar = wordvar
// AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.W2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
// when (segment[0].callLabel) {
// "AX" ->
// """
// sta ${C64Zeropage.SCRATCH_W1}
// stx ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.w2float
// """
// "AY" ->
// """
// sta ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.w2float
// """
// "XY" ->
// """
// stx ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.w2float
// """
// else ->
// """
// lda ${segment[0].callLabel}
// sta ${C64Zeropage.SCRATCH_W1}
// lda ${segment[0].callLabel}+1
// sta ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.w2float
// """
// }
// },
// // floatvar = mem byte
// AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.B2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
// """
// lda ${segment[0].arg!!.integerValue().toHex()}
// sta ${C64Zeropage.SCRATCH_B1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.b2float
// """
// },
// // floatvar = mem ubyte
// AsmPattern(listOf(Opcode.PUSH_MEM_UB, Opcode.UB2FLOAT, Opcode.POP_VAR_FLOAT)) { segment->
// """
// lda ${segment[0].arg!!.integerValue().toHex()}
// sta ${C64Zeropage.SCRATCH_B1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.ub2float
// """
// },
// // floatvar = mem word
// AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.W2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
// """
// lda ${segment[0].arg!!.integerValue().toHex()}
// sta ${C64Zeropage.SCRATCH_W1}
// lda ${(segment[0].arg!!.integerValue()+1).toHex()}
// sta ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.w2float
// """
// },
// // floatvar = mem uword
// AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.UW2FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
// """
// lda ${segment[0].arg!!.integerValue().toHex()}
// sta ${C64Zeropage.SCRATCH_W1}
// lda ${(segment[0].arg!!.integerValue()+1).toHex()}
// sta ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[2].callLabel}
// ldy #>${segment[2].callLabel}
// jsr prog8_lib.uw2float
// """
// },
// // floatvar = floatarray[index]
// AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_FLOAT, Opcode.POP_VAR_FLOAT)) { segment ->
// TODO("$segment")
// },
// // floatvar = floatarray[indexvar] VIA REGULAR STACK EVALUATION FOR NOW: Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_FLOAT, Opcode.POP_VAR_FLOAT) TODO Optimize this in special pattern?
// // floatvar = floatarray[mem index (u)byte] VIA REGULAR STACK EVALUATION FOR NOW: Opcode.PUSH_MEM_[U]B, Opcode.READ_INDEXED_VAR_FLOAT, Opcode.POP_VAR_FLOAT TODO Optimize this in special pattern?
//
//
//
// // ----------- assignment to MEMORY FLOAT ----------------
// // mem = floatvalue
// AsmPattern(listOf(Opcode.PUSH_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
// val floatConst = getFloatConst(segment[0].arg!!)
// """
// lda #<$floatConst
// ldy #>$floatConst
// sta ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[1].arg!!.integerValue().toHex()}
// ldy #>${segment[1].arg!!.integerValue().toHex()}
// jsr prog8_lib.copy_float
// """
// },
// // mem = floatvar
// AsmPattern(listOf(Opcode.PUSH_VAR_FLOAT, Opcode.POP_MEM_FLOAT)) { segment ->
// """
// lda #<${segment[0].callLabel}
// ldy #>${segment[0].callLabel}
// sta ${C64Zeropage.SCRATCH_W1}
// sty ${C64Zeropage.SCRATCH_W1+1}
// lda #<${segment[1].arg!!.integerValue().toHex()}
// ldy #>${segment[1].arg!!.integerValue().toHex()}
// jsr prog8_lib.copy_float
// """
// }
// ---- @todo assignment to arrays follow below ----------
// // assignment: wordarray[idxbyte] = word
// AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->

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

@ -10,8 +10,6 @@ class AssemblyProgram(val name: String) {
private val viceMonListFile = "$name.vice-mon-list"
fun assemble(options: CompilationOptions) {
println("Generating machine code program...")
val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch", "-Wall", "-Wno-strict-bool", "-Wlong-branch",
"-Werror", "-Wno-error=long-branch", "--dump-labels", "--vice-labels", "-l", viceMonListFile, "--no-monitor")
@ -54,4 +52,4 @@ class AssemblyProgram(val name: String) {
breakpoints.add(2, "del")
File(viceMonListFile).appendText(breakpoints.joinToString("\n")+"\n")
}
}
}

5
compiler/src/prog8/stackvm/StackVm.kt
View File

@ -1144,11 +1144,6 @@ class StackVm(private var traceOutputFile: String?) {
checkDt(ubyte, DataType.UBYTE)
evalstack.push(Value(DataType.UWORD, ubyte.integerValue()))
}
Opcode.MSB2WORD -> {
val byte = evalstack.pop()
checkDt(byte, DataType.UBYTE)
evalstack.push(Value(DataType.UWORD, byte.integerValue() * 256))
}
Opcode.B2FLOAT -> {
val byte = evalstack.pop()
checkDt(byte, DataType.BYTE)

16
compiler/test/StackVMOpcodeTests.kt
View File

@ -519,22 +519,6 @@ class TestStackVmOpcodes {
}
}
@Test
fun testMSB2Word() {
val ins = mutableListOf(
Instruction(Opcode.PUSH_WORD, Value(DataType.UWORD, 0xea31)),
Instruction(Opcode.PUSH_BYTE, Value(DataType.UBYTE, 0x45)),
Instruction(Opcode.MSB2WORD),
Instruction(Opcode.MSB2WORD)
)
vm.load(makeProg(ins), null)
vm.step(3)
assertEquals(Value(DataType.UWORD, 0x4500), vm.evalstack.pop())
assertFailsWith<VmExecutionException> {
vm.step(1)
}
}
@Test
fun testB2Float() {
val ins = mutableListOf(