From 4ef680f6fd7f24bdda50d88c59db116ce9f711b5 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Thu, 1 Nov 2018 23:42:10 +0100 Subject: [PATCH] assignments --- compiler/examples/test.p8 | 317 ++++++- .../intermediate/IntermediateProgram.kt | 8 - .../src/prog8/compiler/intermediate/Opcode.kt | 1 - .../src/prog8/compiler/target/c64/AsmGen.kt | 853 +++++++++++++----- .../compiler/target/c64/AssemblyProgram.kt | 4 +- compiler/src/prog8/stackvm/StackVm.kt | 5 - compiler/test/StackVMOpcodeTests.kt | 16 - 7 files changed, 911 insertions(+), 293 deletions(-) diff --git a/compiler/examples/test.p8 b/compiler/examples/test.p8 index 4e14d1811..40f24c267 100644 --- a/compiler/examples/test.p8 +++ b/compiler/examples/test.p8 @@ -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 } diff --git a/compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt b/compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt index ac295b022..456a44068 100644 --- a/compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt +++ b/compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt @@ -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, diff --git a/compiler/src/prog8/compiler/intermediate/Opcode.kt b/compiler/src/prog8/compiler/intermediate/Opcode.kt index f764ebc1d..73f7715c9 100644 --- a/compiler/src/prog8/compiler/intermediate/Opcode.kt +++ b/compiler/src/prog8/compiler/intermediate/Opcode.kt @@ -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 diff --git a/compiler/src/prog8/compiler/target/c64/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/AsmGen.kt index 7c917e750..cb85ede3c 100644 --- a/compiler/src/prog8/compiler/target/c64/AsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/AsmGen.kt @@ -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 -> diff --git a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt index 275a5dc61..3456f5749 100644 --- a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt +++ b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt @@ -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") } -} \ No newline at end of file +} diff --git a/compiler/src/prog8/stackvm/StackVm.kt b/compiler/src/prog8/stackvm/StackVm.kt index b7b73bbfa..433b01149 100644 --- a/compiler/src/prog8/stackvm/StackVm.kt +++ b/compiler/src/prog8/stackvm/StackVm.kt @@ -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) diff --git a/compiler/test/StackVMOpcodeTests.kt b/compiler/test/StackVMOpcodeTests.kt index 07b7bc8db..5addf36de 100644 --- a/compiler/test/StackVMOpcodeTests.kt +++ b/compiler/test/StackVMOpcodeTests.kt @@ -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 { - vm.step(1) - } - } - @Test fun testB2Float() { val ins = mutableListOf(