From d0bd2f522c0897ab659189703d92b54c9574e7c2 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Fri, 6 Nov 2020 23:51:39 +0100 Subject: [PATCH] rol and ror --- compiler/res/prog8lib/cx16/floats.p8 | 1 + compiler/res/prog8lib/prog8_lib.asm | 135 ++++--- .../c64/codegen/BuiltinFunctionsAsmGen.kt | 102 +++--- .../c64/codegen/assignment/AsmAssignment.kt | 8 + .../codegen/assignment/AssignmentAsmGen.kt | 62 ++-- .../src/prog8/functions/BuiltinFunctions.kt | 3 +- examples/test.p8 | 339 ++++++++++++++---- 7 files changed, 415 insertions(+), 235 deletions(-) diff --git a/compiler/res/prog8lib/cx16/floats.p8 b/compiler/res/prog8lib/cx16/floats.p8 index 716a30b5e..88bfc2b96 100644 --- a/compiler/res/prog8lib/cx16/floats.p8 +++ b/compiler/res/prog8lib/cx16/floats.p8 @@ -149,5 +149,6 @@ sub print_f (float value) { } %asminclude "library:c64/floats.asm", "" +%asminclude "library:c64/floats_funcs.asm", "" } diff --git a/compiler/res/prog8lib/prog8_lib.asm b/compiler/res/prog8lib/prog8_lib.asm index 6e513f308..e0b10dec6 100644 --- a/compiler/res/prog8lib/prog8_lib.asm +++ b/compiler/res/prog8lib/prog8_lib.asm @@ -743,12 +743,9 @@ _done rts ror2_mem_ub .proc - ; -- in-place 8-bit ror of byte at memory location on stack - inx - lda P8ESTACK_LO,x + ; -- in-place 8-bit ror of byte at memory location in AY sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 ldy #0 lda (P8ZP_SCRATCH_W1),y lsr a @@ -759,12 +756,9 @@ ror2_mem_ub .proc .pend rol2_mem_ub .proc - ; -- in-place 8-bit rol of byte at memory location on stack - inx - lda P8ESTACK_LO,x + ; -- in-place 8-bit rol of byte at memory location in AY sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 ldy #0 lda (P8ZP_SCRATCH_W1),y cmp #$80 @@ -774,81 +768,79 @@ rol2_mem_ub .proc .pend rol_array_ub .proc - ; -- rol a ubyte in an array (index and array address on stack) - inx - ldy P8ESTACK_LO,x - inx - lda P8ESTACK_LO,x + ; -- rol a ubyte in an array + lda _arg_target + ldy _arg_target+1 sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 + ldy _arg_index lda (P8ZP_SCRATCH_W1),y rol a sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend ror_array_ub .proc - ; -- ror a ubyte in an array (index and array address on stack) - inx - ldy P8ESTACK_LO,x - inx - lda P8ESTACK_LO,x + ; -- ror a ubyte in an array + lda _arg_target + ldy _arg_target+1 sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 + ldy _arg_index lda (P8ZP_SCRATCH_W1),y ror a sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend ror2_array_ub .proc - ; -- ror2 (8-bit ror) a ubyte in an array (index and array address on stack) - inx - ldy P8ESTACK_LO,x - inx - lda P8ESTACK_LO,x + ; -- ror2 (8-bit ror) a ubyte in an array + lda _arg_target + ldy _arg_target+1 sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 + ldy _arg_index lda (P8ZP_SCRATCH_W1),y lsr a bcc + ora #$80 + sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend rol2_array_ub .proc - ; -- rol2 (8-bit rol) a ubyte in an array (index and array address on stack) - inx - ldy P8ESTACK_LO,x - inx - lda P8ESTACK_LO,x + ; -- rol2 (8-bit rol) a ubyte in an array + lda _arg_target + ldy _arg_target+1 sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 + sty P8ZP_SCRATCH_W1+1 + ldy _arg_index lda (P8ZP_SCRATCH_W1),y cmp #$80 rol a sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend ror_array_uw .proc - ; -- ror a uword in an array (index and array address on stack) + ; -- ror a uword in an array php - inx - lda P8ESTACK_LO,x + lda _arg_target + ldy _arg_target+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + lda _arg_index asl a tay - inx - lda P8ESTACK_LO,x - sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 iny lda (P8ZP_SCRATCH_W1),y plp @@ -859,20 +851,20 @@ ror_array_uw .proc ror a sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend rol_array_uw .proc - ; -- rol a uword in an array (index and array address on stack) + ; -- rol a uword in an array php - inx - lda P8ESTACK_LO,x + lda _arg_target + ldy _arg_target+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + lda _arg_index asl a tay - inx - lda P8ESTACK_LO,x - sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 lda (P8ZP_SCRATCH_W1),y plp rol a @@ -882,19 +874,19 @@ rol_array_uw .proc rol a sta (P8ZP_SCRATCH_W1),y rts +_arg_target .word 0 +_arg_index .byte 0 .pend rol2_array_uw .proc - ; -- rol2 (16-bit rol) a uword in an array (index and array address on stack) - inx - lda P8ESTACK_LO,x + ; -- rol2 (16-bit rol) a uword in an array + lda _arg_target + ldy _arg_target+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + lda _arg_index asl a tay - inx - lda P8ESTACK_LO,x - sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 lda (P8ZP_SCRATCH_W1),y asl a sta (P8ZP_SCRATCH_W1),y @@ -908,19 +900,19 @@ rol2_array_uw .proc adc #0 sta (P8ZP_SCRATCH_W1),y + rts +_arg_target .word 0 +_arg_index .byte 0 .pend ror2_array_uw .proc - ; -- ror2 (16-bit ror) a uword in an array (index and array address on stack) - inx - lda P8ESTACK_LO,x + ; -- ror2 (16-bit ror) a uword in an array + lda _arg_target + ldy _arg_target+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + lda _arg_index asl a tay - inx - lda P8ESTACK_LO,x - sta P8ZP_SCRATCH_W1 - lda P8ESTACK_HI,x - sta P8ZP_SCRATCH_W1+1 iny lda (P8ZP_SCRATCH_W1),y lsr a @@ -935,6 +927,8 @@ ror2_array_uw .proc ora #$80 sta (P8ZP_SCRATCH_W1),y + rts +_arg_target .word 0 +_arg_index .byte 0 .pend @@ -945,7 +939,6 @@ strcpy .proc sty P8ZP_SCRATCH_W2+1 ldy #$ff - iny - inc $d020 lda (P8ZP_SCRATCH_W2),y sta (P8ZP_SCRATCH_W1),y bne - diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt index 8127d61d7..1ec15dabb 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt @@ -5,6 +5,7 @@ import prog8.ast.Node import prog8.ast.Program import prog8.ast.base.* import prog8.ast.expressions.* +import prog8.ast.statements.ArrayIndex import prog8.ast.statements.DirectMemoryWrite import prog8.ast.statements.FunctionCallStatement import prog8.compiler.AssemblyError @@ -268,17 +269,16 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UBYTE -> { when (what) { is ArrayIndexedExpression -> { - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.ror2_array_ub_cc") // TODO cc + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror2", 'b') + asmgen.out(" jsr prog8_lib.ror2_array_ub") } is DirectMemoryRead -> { if (what.addressExpression is NumericLiteralValue) { val number = (what.addressExpression as NumericLiteralValue).number asmgen.out(" lda ${number.toHex()} | lsr a | bcc + | ora #\$80 |+ | sta ${number.toHex()}") } else { - asmgen.translateExpression(what.addressExpression) - asmgen.out(" jsr prog8_lib.ror2_mem_ub_cc") // TODO cc + translateRolRorMemoryArgs(what.addressExpression, fcall) + asmgen.out(" jsr prog8_lib.ror2_mem_ub") } } is IdentifierReference -> { @@ -291,10 +291,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UWORD -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.ror2_array_uw_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror2", 'w') + asmgen.out(" jsr prog8_lib.ror2_array_uw") } is IdentifierReference -> { val variable = asmgen.asmVariableName(what) @@ -314,26 +312,19 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UBYTE -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.ror_array_ub_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror", 'b') + asmgen.out(" jsr prog8_lib.ror_array_ub") } is DirectMemoryRead -> { if (what.addressExpression is NumericLiteralValue) { val number = (what.addressExpression as NumericLiteralValue).number asmgen.out(" ror ${number.toHex()}") } else { - // TODO cc - asmgen.translateExpression(what.addressExpression) + translateRolRorMemoryArgs(what.addressExpression, fcall) asmgen.out(""" - inx - lda P8ESTACK_LO,x - sta (+) + 1 - lda P8ESTACK_HI,x - sta (+) + 2 - + ror ${'$'}ffff ; modified - """) + sta (+) + 1 + sty (+) + 2 ++ ror ${'$'}ffff ; modified""") } } is IdentifierReference -> { @@ -346,10 +337,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UWORD -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.ror_array_uw_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "ror", 'w') + asmgen.out(" jsr prog8_lib.ror_array_uw") } is IdentifierReference -> { val variable = asmgen.asmVariableName(what) @@ -369,19 +358,16 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UBYTE -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.rol2_array_ub_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol2", 'b') + asmgen.out(" jsr prog8_lib.rol2_array_ub") } is DirectMemoryRead -> { if (what.addressExpression is NumericLiteralValue) { val number = (what.addressExpression as NumericLiteralValue).number asmgen.out(" lda ${number.toHex()} | cmp #\$80 | rol a | sta ${number.toHex()}") } else { - // TODO cc - asmgen.translateExpression(what.addressExpression) - asmgen.out(" jsr prog8_lib.rol2_mem_ub_cc") + translateRolRorMemoryArgs(what.addressExpression, fcall) + asmgen.out(" jsr prog8_lib.rol2_mem_ub") } } is IdentifierReference -> { @@ -394,10 +380,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UWORD -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.rol2_array_uw_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol2", 'w') + asmgen.out(" jsr prog8_lib.rol2_array_uw") } is IdentifierReference -> { val variable = asmgen.asmVariableName(what) @@ -417,26 +401,19 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UBYTE -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.rol_array_ub_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol", 'b') + asmgen.out(" jsr prog8_lib.rol_array_ub") } is DirectMemoryRead -> { if (what.addressExpression is NumericLiteralValue) { val number = (what.addressExpression as NumericLiteralValue).number asmgen.out(" rol ${number.toHex()}") } else { - // TODO cc - asmgen.translateExpression(what.addressExpression) + translateRolRorMemoryArgs(what.addressExpression, fcall) asmgen.out(""" - inx - lda P8ESTACK_LO,x - sta (+) + 1 - lda P8ESTACK_HI,x - sta (+) + 2 - + rol ${'$'}ffff ; modified - """) + sta (+) + 1 + sty (+) + 2 ++ rol ${'$'}ffff ; modified""") } } is IdentifierReference -> { @@ -449,10 +426,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val DataType.UWORD -> { when (what) { is ArrayIndexedExpression -> { - // TODO cc - asmgen.translateExpression(what.arrayvar) - asmgen.translateExpression(what.indexer) - asmgen.out(" jsr prog8_lib.rol_array_uw_cc") + translateRolRorArrayArgs(what.arrayvar, what.indexer, fcall, "rol", 'w') + asmgen.out(" jsr prog8_lib.rol_array_uw") } is IdentifierReference -> { val variable = asmgen.asmVariableName(what) @@ -465,6 +440,24 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } + private fun translateRolRorMemoryArgs(addressExpression: Expression, fcall: IFunctionCall) { + val src = AsmAssignSource.fromAstSource(addressExpression, program, asmgen) + val tgt = AsmAssignTarget.fromRegisters(RegisterOrPair.AY, null, program, asmgen) + val assign = AsmAssignment(src, tgt, false, (fcall as Node).position) + asmgen.translateNormalAssignment(assign) + } + + private fun translateRolRorArrayArgs(arrayvar: IdentifierReference, indexer: ArrayIndex, fcall: IFunctionCall, operation: String, dt: Char) { + var src = AsmAssignSource.fromAstSource(AddressOf(arrayvar, (fcall as Node).position), program, asmgen) + var tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, null, variableAsmName = "prog8_lib.${operation}_array_u${dt}._arg_target") + var assign = AsmAssignment(src, tgt, false, (fcall as Node).position) + asmgen.translateNormalAssignment(assign) + src = AsmAssignSource.fromAstSource(indexer, program, asmgen) + tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UBYTE, null, variableAsmName = "prog8_lib.${operation}_array_u${dt}._arg_index") + assign = AsmAssignment(src, tgt, false, (fcall as Node).position) + asmgen.translateNormalAssignment(assign) + } + private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean) { translateArguments(fcall.args, func) if(resultToStack) @@ -686,6 +679,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } + // TODO find alternative way to swap here without using estack asmgen.translateExpression(first) asmgen.translateExpression(second) val idatatype = first.inferType(program) diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt index 465cc2f38..48a0a9f79 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt @@ -101,6 +101,14 @@ internal class AsmAssignSource(val kind: SourceStorageKind, asmgen.asmVariableName(array.arrayvar) companion object { + fun fromAstSource(indexer: ArrayIndex, program: Program, asmgen: AsmGen): AsmAssignSource { + return when { + indexer.indexNum!=null -> fromAstSource(indexer.indexNum!!, program, asmgen) + indexer.indexVar!=null -> fromAstSource(indexer.indexVar!!, program, asmgen) + else -> throw AssemblyError("weird indexer") + } + } + fun fromAstSource(value: Expression, program: Program, asmgen: AsmGen): AsmAssignSource { val cv = value.constValue(program) if(cv!=null) diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt index 5149d5d12..10005ffee 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt @@ -131,37 +131,41 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen val preserveStatusRegisterAfterCall = sub.asmReturnvaluesRegisters.any { it.statusflag != null } asmgen.translateFunctionCall(value, preserveStatusRegisterAfterCall) val returnValue = sub.returntypes.zip(sub.asmReturnvaluesRegisters).single { it.second.registerOrPair!=null } - if(returnValue.first==DataType.STR) { - when(assign.target.datatype) { - DataType.UWORD -> { - // assign the address of the string result value - assignRegisterpairWord(assign.target, RegisterOrPair.AY) + when (returnValue.first) { + DataType.STR -> { + when(assign.target.datatype) { + DataType.UWORD -> { + // assign the address of the string result value + assignRegisterpairWord(assign.target, RegisterOrPair.AY) + } + DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> { + // copy the actual string result into the target string variable + asmgen.out(""" + pha + lda #<${assign.target.asmVarname} + sta P8ZP_SCRATCH_W1 + lda #>${assign.target.asmVarname} + sta P8ZP_SCRATCH_W1+1 + pla + jsr prog8_lib.strcpy""") + } + else -> throw AssemblyError("weird target dt") } - DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> { - // copy the actual string result into the target string variable - asmgen.out(""" - pha - lda #<${assign.target.asmVarname} - sta P8ZP_SCRATCH_W1 - lda #>${assign.target.asmVarname} - sta P8ZP_SCRATCH_W1+1 - pla - jsr prog8_lib.strcpy""") - } - else -> throw AssemblyError("weird target dt") } - } else if(returnValue.first==DataType.FLOAT) { - // float result from function sits in FAC1 - assignFAC1float(assign.target) - } else { - when (returnValue.second.registerOrPair) { - RegisterOrPair.A -> assignRegisterByte(assign.target, CpuRegister.A) - RegisterOrPair.X -> assignRegisterByte(assign.target, CpuRegister.X) - RegisterOrPair.Y -> assignRegisterByte(assign.target, CpuRegister.Y) - RegisterOrPair.AX -> assignRegisterpairWord(assign.target, RegisterOrPair.AX) - RegisterOrPair.AY -> assignRegisterpairWord(assign.target, RegisterOrPair.AY) - RegisterOrPair.XY -> assignRegisterpairWord(assign.target, RegisterOrPair.XY) - else -> throw AssemblyError("should be just one register byte result value") + DataType.FLOAT -> { + // float result from function sits in FAC1 + assignFAC1float(assign.target) + } + else -> { + when (returnValue.second.registerOrPair) { + RegisterOrPair.A -> assignRegisterByte(assign.target, CpuRegister.A) + RegisterOrPair.X -> assignRegisterByte(assign.target, CpuRegister.X) + RegisterOrPair.Y -> assignRegisterByte(assign.target, CpuRegister.Y) + RegisterOrPair.AX -> assignRegisterpairWord(assign.target, RegisterOrPair.AX) + RegisterOrPair.AY -> assignRegisterpairWord(assign.target, RegisterOrPair.AY) + RegisterOrPair.XY -> assignRegisterpairWord(assign.target, RegisterOrPair.XY) + else -> throw AssemblyError("should be just one register byte result value") + } } } if (preserveStatusRegisterAfterCall) diff --git a/compiler/src/prog8/functions/BuiltinFunctions.kt b/compiler/src/prog8/functions/BuiltinFunctions.kt index 985f576b6..c5d85edce 100644 --- a/compiler/src/prog8/functions/BuiltinFunctions.kt +++ b/compiler/src/prog8/functions/BuiltinFunctions.kt @@ -69,8 +69,7 @@ class FSignature(val name: String, actualParamTypes.isEmpty() -> CallConvention(emptyList(), returns) actualParamTypes.size==1 -> { // one parameter? via register/registerpair - val paramType = actualParamTypes[0] - val paramConv = when(paramType) { + val paramConv = when(val paramType = actualParamTypes[0]) { DataType.UBYTE, DataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false) DataType.UWORD, DataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false) DataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false) diff --git a/examples/test.p8 b/examples/test.p8 index dd284dcb7..de9a3c5b3 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -3,48 +3,270 @@ %import syslib %zeropage basicsafe -; builtin functions converted to new call convention: -; -; all functions operating on floating-point and fp arrays. -; -; mkword -; lsb -; msb -; swap - -; abs -; sgn -; sqrt16 -; rnd, rndw -; sin8, sin8u, cos8, cos8u -; sin16, sin16u, cos16, cos16u -; max, min -; any, all -; sum -; sort -; reverse - -; exit -; read_flags -; memset, memsetw, memcopy -; leftstr, rightstr, substr -; strlen, strcmp - -; TODO: in-place rols and rors - main { sub start() { - const uword ADDR = $0400 - const uword ADDR2 = $4000 + rotations() + strings() + integers() + floatingpoint() -; memset(ADDR2, 40*25, '*') -; memset(ADDR2, 40, '1') -; memset(ADDR2+24*40, 39, '2') -; memsetw(ADDR2, 40*25/2, $3132) -; memsetw(ADDR2, 20, $4142) -; memsetw(ADDR2+24*40, 19, $4241) -; memcopy(ADDR2, ADDR, 200) + testX() + } + + sub rotations() { + ubyte[] ubarr = [%11000111] + uword[] uwarr = [%1100111110101010] + + repeat(10) { + txt.chrout('\n') + } + + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + rol(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + rol(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + rol(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + rol(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + uwarr[0] = %1100111110101010 + ror(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + ror(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + ror(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + ror(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + set_carry() + ror(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + clear_carry() + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + rol2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + rol2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + rol2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + rol2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + ror2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + ror2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + ror2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + ror2(uwarr[0]) + txt.print_uwbin(uwarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + rol(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + rol(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + rol(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + rol(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + set_carry() + ror(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + ror(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + ror(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + ror(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + set_carry() + ror(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + rol2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + rol2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + rol2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + rol2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + ror2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + ror2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + ror2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + ror2(ubarr[0]) + txt.print_ubbin(ubarr[0], true) + txt.chrout('\n') + txt.chrout('\n') + + &ubyte membyte = $c000 + uword addr = $c000 + + @(addr) = %10110101 + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + rol(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + rol(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + rol(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + rol(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + txt.chrout('\n') + + @(addr) = %10110101 + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + ror(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + ror(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + ror(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + set_carry() + ror(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + txt.chrout('\n') + + @(addr) = %10110101 + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + rol2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + rol2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + rol2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + rol2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + txt.chrout('\n') + + @(addr) = %10110101 + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + ror2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + ror2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + ror2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + ror2(@(addr)) + txt.print_ubbin(@(addr), true) + txt.chrout('\n') + txt.chrout('\n') + + + testX() + + } + + sub strings() { + const uword ADDR = $8400 + const uword ADDR2 = $8000 + + memset(ADDR2, 40*25, '*') + memset(ADDR2, 40, '1') + memset(ADDR2+24*40, 39, '2') + memsetw(ADDR2, 40*25/2, $3132) + memsetw(ADDR2, 20, $4142) + memsetw(ADDR2+24*40, 19, $4241) + memcopy(ADDR2, ADDR, 200) str result = "?" *10 str s1 = "irmen" @@ -609,47 +831,6 @@ main { floats.print_f(fl) txt.chrout('\n') -; ub = min(barr) -; -; ub = zero+min(barr)*1+zero -; txt.print_ub(ub) -; txt.chrout('\n') -; -; ub = max(barr) -; txt.print_ub(ub) -; txt.chrout('\n') -; -; ub = zero+max(barr)*1+zero -; txt.print_ub(ub) -; txt.chrout('\n') -; -; uw = sum(barr) -; txt.print_uw(uw) -; txt.chrout('\n') -; -; uw = zero+sum(barr)*1+zero -; txt.print_uw(uw) -; txt.chrout('\n') -; -; ub = any(barr) -; txt.print_ub(ub) -; txt.chrout('\n') -; -; ub = zero+any(barr)*1 -; txt.print_ub(ub) -; txt.chrout('\n') -; -; ub = all(barr) -; txt.print_ub(ub) -; txt.chrout('\n') -; -; ub = zero+all(barr)*1 -; txt.print_ub(ub) -; txt.chrout('\n') - - - - testX() }