From 78bdbde3ae5f4bdee9968948271889e40caeb58e Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Tue, 25 Aug 2020 19:44:08 +0200 Subject: [PATCH] refer to ZP scratch constants from asm code via the global P8ZP constants as well --- compiler/res/prog8lib/c64floats.asm | 334 ++-- compiler/res/prog8lib/c64flt.p8 | 20 +- compiler/res/prog8lib/c64lib.p8 | 10 - compiler/res/prog8lib/c64utils.p8 | 148 +- compiler/res/prog8lib/math.asm | 629 ++++---- compiler/res/prog8lib/prog8lib.asm | 1384 +++++++++-------- .../target/c64/codegen/FunctionCallAsmGen.kt | 4 +- .../assignment/AugmentableAssignmentAsmGen.kt | 16 +- examples/c64graphics.p8 | 20 +- 9 files changed, 1279 insertions(+), 1286 deletions(-) diff --git a/compiler/res/prog8lib/c64floats.asm b/compiler/res/prog8lib/c64floats.asm index 6fa64bcf7..e13e50354 100644 --- a/compiler/res/prog8lib/c64floats.asm +++ b/compiler/res/prog8lib/c64floats.asm @@ -4,47 +4,47 @@ ub2float .proc ; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y ; clobbers A, Y - stx c64.SCRATCH_ZPREGX - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 - ldy c64.SCRATCH_ZPB1 + stx P8ZP_SCRATCH_REG_X + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 + ldy P8ZP_SCRATCH_B1 jsr FREADUY -_fac_to_mem ldx c64.SCRATCH_ZPWORD2 - ldy c64.SCRATCH_ZPWORD2+1 +_fac_to_mem ldx P8ZP_SCRATCH_W2 + ldy P8ZP_SCRATCH_W2+1 jsr MOVMF - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts .pend b2float .proc ; -- convert byte in SCRATCH_ZPB1 to float at address A/Y ; clobbers A, Y - stx c64.SCRATCH_ZPREGX - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 - lda c64.SCRATCH_ZPB1 + stx P8ZP_SCRATCH_REG_X + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 + lda P8ZP_SCRATCH_B1 jsr FREADSA jmp ub2float._fac_to_mem .pend uw2float .proc ; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y - stx c64.SCRATCH_ZPREGX - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + stx P8ZP_SCRATCH_REG_X + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr GIVUAYFAY jmp ub2float._fac_to_mem .pend w2float .proc ; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y - stx c64.SCRATCH_ZPREGX - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 - ldy c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + stx P8ZP_SCRATCH_REG_X + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 + ldy P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 jsr GIVAYF jmp ub2float._fac_to_mem .pend @@ -52,8 +52,8 @@ w2float .proc stack_b2float .proc ; -- b2float operating on the stack inx - lda c64.ESTACK_LO,x - stx c64.SCRATCH_ZPREGX + lda P8ESTACK_LO,x + stx P8ZP_SCRATCH_REG_X jsr FREADSA jmp push_fac1_as_result .pend @@ -61,9 +61,9 @@ stack_b2float .proc stack_w2float .proc ; -- w2float operating on the stack inx - ldy c64.ESTACK_LO,x - lda c64.ESTACK_HI,x - stx c64.SCRATCH_ZPREGX + ldy P8ESTACK_LO,x + lda P8ESTACK_HI,x + stx P8ZP_SCRATCH_REG_X jsr GIVAYF jmp push_fac1_as_result .pend @@ -71,8 +71,8 @@ stack_w2float .proc stack_ub2float .proc ; -- ub2float operating on the stack inx - lda c64.ESTACK_LO,x - stx c64.SCRATCH_ZPREGX + lda P8ESTACK_LO,x + stx P8ZP_SCRATCH_REG_X tay jsr FREADUY jmp push_fac1_as_result @@ -81,34 +81,34 @@ stack_ub2float .proc stack_uw2float .proc ; -- uw2float operating on the stack inx - lda c64.ESTACK_LO,x - ldy c64.ESTACK_HI,x - stx c64.SCRATCH_ZPREGX + lda P8ESTACK_LO,x + ldy P8ESTACK_HI,x + stx P8ZP_SCRATCH_REG_X jsr GIVUAYFAY jmp push_fac1_as_result .pend stack_float2w .proc ; also used for float2b jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr AYINT - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X lda $64 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x lda $65 - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend stack_float2uw .proc ; also used for float2ub jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr GETADR - ldx c64.SCRATCH_ZPREGX - sta c64.ESTACK_HI,x + ldx P8ZP_SCRATCH_REG_X + sta P8ESTACK_HI,x tya - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend @@ -116,39 +116,39 @@ stack_float2uw .proc ; also used for float2ub push_float .proc ; ---- push mflpt5 in A/Y onto stack ; (taking 3 stack positions = 6 bytes of which 1 is padding) - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 ldy #0 - lda (c64.SCRATCH_ZPWORD1),y - sta c64.ESTACK_LO,x + lda (P8ZP_SCRATCH_W1),y + sta P8ESTACK_LO,x iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.ESTACK_HI,x + lda (P8ZP_SCRATCH_W1),y + sta P8ESTACK_HI,x dex iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.ESTACK_LO,x + lda (P8ZP_SCRATCH_W1),y + sta P8ESTACK_LO,x iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.ESTACK_HI,x + lda (P8ZP_SCRATCH_W1),y + sta P8ESTACK_HI,x dex iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.ESTACK_LO,x + lda (P8ZP_SCRATCH_W1),y + sta P8ESTACK_LO,x dex rts .pend func_rndf .proc ; -- put a random floating point value on the stack - stx c64.SCRATCH_ZPREG + stx P8ZP_SCRATCH_REG lda #1 jsr FREADSA jsr RND ; rng into fac1 ldx #<_rndf_rnum5 ldy #>_rndf_rnum5 jsr MOVMF ; fac1 to mem X/Y - ldx c64.SCRATCH_ZPREG + ldx P8ZP_SCRATCH_REG lda #<_rndf_rnum5 ldy #>_rndf_rnum5 jmp push_float @@ -158,26 +158,26 @@ _rndf_rnum5 .byte 0,0,0,0,0 pop_float .proc ; ---- pops mflpt5 from stack to memory A/Y ; (frees 3 stack positions = 6 bytes of which 1 is padding) - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 ldy #4 inx - lda c64.ESTACK_LO,x - sta (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta (P8ZP_SCRATCH_W1),y dey inx - lda c64.ESTACK_HI,x - sta (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_HI,x + sta (P8ZP_SCRATCH_W1),y dey - lda c64.ESTACK_LO,x - sta (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta (P8ZP_SCRATCH_W1),y dey inx - lda c64.ESTACK_HI,x - sta (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_HI,x + sta (P8ZP_SCRATCH_W1),y dey - lda c64.ESTACK_LO,x - sta (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta (P8ZP_SCRATCH_W1),y rts .pend @@ -203,12 +203,12 @@ pop_float_fac2 .proc pop_float_to_indexed_var .proc ; -- pop the float on the stack, to the memory in the array at A/Y indexed by the byte on stack - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 jsr prog8_lib.pop_index_times_5 jsr prog8_lib.add_a_to_zpword - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jmp pop_float .pend @@ -218,7 +218,7 @@ copy_float .proc sta _target+1 sty _target+2 ldy #4 -_loop lda (c64.SCRATCH_ZPWORD1),y +_loop lda (P8ZP_SCRATCH_W1),y _target sta $ffff,y ; modified dey bpl _loop @@ -227,35 +227,35 @@ _target sta $ffff,y ; modified inc_var_f .proc ; -- add 1 to float pointed to by A/Y - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 - stx c64.SCRATCH_ZPREGX + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + stx P8ZP_SCRATCH_REG_X jsr MOVFM lda #FL_FONE jsr FADD - ldx c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + ldx P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr MOVMF - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts .pend dec_var_f .proc ; -- subtract 1 from float pointed to by A/Y - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 - stx c64.SCRATCH_ZPREGX + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 + stx P8ZP_SCRATCH_REG_X lda #FL_FONE jsr MOVFM - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr FSUB - ldx c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + ldx P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr MOVMF - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts .pend @@ -284,7 +284,7 @@ push_fac1_as_result .proc jsr MOVMF lda #fmath_float1 - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X jmp push_float .pend @@ -296,21 +296,21 @@ pow_f .proc lda #fmath_float1 jsr pop_float - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #fmath_float1 jsr CONUPK ; fac2 = float1 lda #fmath_float2 jsr FPWR - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X jmp push_fac1_as_result .pend div_f .proc ; -- push f1/f2 on stack jsr pop_2_floats_f2_in_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #fmath_float1 jsr FDIV @@ -320,7 +320,7 @@ div_f .proc add_f .proc ; -- push f1+f2 on stack jsr pop_2_floats_f2_in_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #fmath_float1 jsr FADD @@ -330,7 +330,7 @@ add_f .proc sub_f .proc ; -- push f1-f2 on stack jsr pop_2_floats_f2_in_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #fmath_float1 jsr FSUB @@ -340,7 +340,7 @@ sub_f .proc mul_f .proc ; -- push f1*f2 on stack jsr pop_2_floats_f2_in_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #fmath_float1 jsr FMULT @@ -350,7 +350,7 @@ mul_f .proc neg_f .proc ; -- push -flt back on stack jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr NEGOP jmp push_fac1_as_result .pend @@ -358,7 +358,7 @@ neg_f .proc abs_f .proc ; -- push abs(float) on stack (as float) jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr ABS jmp push_fac1_as_result .pend @@ -369,24 +369,24 @@ equal_f .proc inx inx inx - lda c64.ESTACK_LO-3,x - cmp c64.ESTACK_LO,x + lda P8ESTACK_LO-3,x + cmp P8ESTACK_LO,x bne _equals_false - lda c64.ESTACK_LO-2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO-2,x + cmp P8ESTACK_LO+1,x bne _equals_false - lda c64.ESTACK_LO-1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO-1,x + cmp P8ESTACK_LO+2,x bne _equals_false - lda c64.ESTACK_HI-2,x - cmp c64.ESTACK_HI+1,x + lda P8ESTACK_HI-2,x + cmp P8ESTACK_HI+1,x bne _equals_false - lda c64.ESTACK_HI-1,x - cmp c64.ESTACK_HI+2,x + lda P8ESTACK_HI-1,x + cmp P8ESTACK_HI+2,x bne _equals_false _equals_true lda #1 _equals_store inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _equals_false lda #0 beq _equals_store @@ -396,7 +396,7 @@ notequal_f .proc ; -- are the two mflpt5 numbers on the stack different? jsr equal_f eor #1 ; invert the result - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -449,12 +449,12 @@ compare_floats .proc jsr MOVFM ; fac1 = flt1 lda #fmath_float2 - stx c64.SCRATCH_ZPREG + stx P8ZP_SCRATCH_REG jsr FCOMP ; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1_pi_div_180 jsr FMULT @@ -535,7 +535,7 @@ _pi_div_180 .byte 123, 14, 250, 53, 18 ; pi / 180 func_deg .proc ; -- convert radians to degrees (d * (1/ pi * 180)) jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #<_one_over_pi_div_180 ldy #>_one_over_pi_div_180 jsr FMULT @@ -545,7 +545,7 @@ _one_over_pi_div_180 .byte 134, 101, 46, 224, 211 ; 1 / (pi * 180) func_round .proc jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr FADDH jsr INT jmp push_fac1_as_result @@ -553,7 +553,7 @@ func_round .proc func_floor .proc jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr INT jmp push_fac1_as_result .pend @@ -561,7 +561,7 @@ func_floor .proc func_ceil .proc ; -- ceil: tr = int(f); if tr==f -> return else return tr+1 jsr pop_float_fac1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X ldx #fmath_float1 jsr MOVMF @@ -579,45 +579,45 @@ func_ceil .proc func_any_f .proc inx - lda c64.ESTACK_LO,x ; array size - sta c64.SCRATCH_ZPB1 + lda P8ESTACK_LO,x ; array size + sta P8ZP_SCRATCH_B1 asl a asl a clc - adc c64.SCRATCH_ZPB1 ; times 5 because of float + adc P8ZP_SCRATCH_B1 ; times 5 because of float jmp prog8_lib.func_any_b._entry .pend func_all_f .proc inx jsr prog8_lib.peek_address - lda c64.ESTACK_LO,x ; array size - sta c64.SCRATCH_ZPB1 + lda P8ESTACK_LO,x ; array size + sta P8ZP_SCRATCH_B1 asl a asl a clc - adc c64.SCRATCH_ZPB1 ; times 5 because of float + adc P8ZP_SCRATCH_B1 ; times 5 because of float tay dey -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y clc dey - adc (c64.SCRATCH_ZPWORD1),y + adc (P8ZP_SCRATCH_W1),y dey - adc (c64.SCRATCH_ZPWORD1),y + adc (P8ZP_SCRATCH_W1),y dey - adc (c64.SCRATCH_ZPWORD1),y + adc (P8ZP_SCRATCH_W1),y dey - adc (c64.SCRATCH_ZPWORD1),y + adc (P8ZP_SCRATCH_W1),y dey cmp #0 beq + cpy #255 bne - lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts -+ sta c64.ESTACK_LO+1,x ++ sta P8ESTACK_LO+1,x rts .pend @@ -628,23 +628,23 @@ func_max_f .proc ldy #>_largest_neg_float _minmax_entry jsr MOVFM jsr prog8_lib.pop_array_and_lengthmin1Y - stx c64.SCRATCH_ZPREGX -- sty c64.SCRATCH_ZPREG - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + stx P8ZP_SCRATCH_REG_X +- sty P8ZP_SCRATCH_REG + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr FCOMP _minmax_cmp cmp #255 ; modified bne + - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr MOVFM -+ lda c64.SCRATCH_ZPWORD1 ++ lda P8ZP_SCRATCH_W1 clc adc #5 - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 bcc + - inc c64.SCRATCH_ZPWORD1+1 -+ ldy c64.SCRATCH_ZPREG + inc P8ZP_SCRATCH_W1+1 ++ ldy P8ZP_SCRATCH_REG dey cpy #255 bne - @@ -667,21 +667,21 @@ func_sum_f .proc ldy #>FL_ZERO jsr MOVFM jsr prog8_lib.pop_array_and_lengthmin1Y - stx c64.SCRATCH_ZPREGX -- sty c64.SCRATCH_ZPREG - lda c64.SCRATCH_ZPWORD1 - ldy c64.SCRATCH_ZPWORD1+1 + stx P8ZP_SCRATCH_REG_X +- sty P8ZP_SCRATCH_REG + lda P8ZP_SCRATCH_W1 + ldy P8ZP_SCRATCH_W1+1 jsr FADD - ldy c64.SCRATCH_ZPREG + ldy P8ZP_SCRATCH_REG dey cpy #255 beq + - lda c64.SCRATCH_ZPWORD1 + lda P8ZP_SCRATCH_W1 clc adc #5 - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 bcc - - inc c64.SCRATCH_ZPWORD1+1 + inc P8ZP_SCRATCH_W1+1 bne - + jmp push_fac1_as_result .pend @@ -689,7 +689,7 @@ func_sum_f .proc sign_f .proc jsr pop_float_fac1 jsr SIGN - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend @@ -698,22 +698,22 @@ sign_f .proc set_0_array_float .proc ; -- set a float in an array to zero (index on stack, array in SCRATCH_ZPWORD1) inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a asl a clc - adc c64.ESTACK_LO,x + adc P8ESTACK_LO,x tay lda #0 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend @@ -721,13 +721,13 @@ set_0_array_float .proc set_array_float .proc ; -- set a float in an array to a value (index on stack, float in SCRATCH_ZPWORD1, array in SCRATCH_ZPWORD2) inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a asl a clc - adc c64.ESTACK_LO,x - adc c64.SCRATCH_ZPWORD2 - ldy c64.SCRATCH_ZPWORD2+1 + adc P8ESTACK_LO,x + adc P8ZP_SCRATCH_W2 + ldy P8ZP_SCRATCH_W2+1 bcc + iny + jmp copy_float @@ -739,12 +739,12 @@ set_array_float .proc swap_floats .proc ; -- swap floats pointed to by SCRATCH_ZPWORD1, SCRATCH_ZPWORD2 ldy #4 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y pha - lda (c64.SCRATCH_ZPWORD2),y - sta (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W2),y + sta (P8ZP_SCRATCH_W1),y pla - sta (c64.SCRATCH_ZPWORD2),y + sta (P8ZP_SCRATCH_W2),y dey bpl - rts diff --git a/compiler/res/prog8lib/c64flt.p8 b/compiler/res/prog8lib/c64flt.p8 index 7cbf08dca..bce969932 100644 --- a/compiler/res/prog8lib/c64flt.p8 +++ b/compiler/res/prog8lib/c64flt.p8 @@ -163,9 +163,9 @@ asmsub GIVUAYFAY (uword value @ AY) clobbers(A,X,Y) { asmsub GIVAYFAY (uword value @ AY) clobbers(A,X,Y) { ; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1 %asm {{ - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG tya - ldy c64.SCRATCH_ZPREG + ldy P8ZP_SCRATCH_REG jmp GIVAYF ; this uses the inverse order, Y/A }} } @@ -174,9 +174,9 @@ asmsub FTOSWRDAY () clobbers(X) -> uword @ AY { ; ---- fac1 to signed word in A/Y %asm {{ jsr FTOSWORDYA ; note the inverse Y/A order - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG tya - ldy c64.SCRATCH_ZPREG + ldy P8ZP_SCRATCH_REG rts }} } @@ -185,9 +185,9 @@ asmsub GETADRAY () clobbers(X) -> uword @ AY { ; ---- fac1 to unsigned word in A/Y %asm {{ jsr GETADR ; this uses the inverse order, Y/A - sta c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 tya - ldy c64.SCRATCH_ZPB1 + ldy P8ZP_SCRATCH_B1 rts }} } @@ -195,13 +195,13 @@ asmsub GETADRAY () clobbers(X) -> uword @ AY { sub print_f (float value) { ; ---- prints the floating point value (without a newline) using basic rom routines. %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #value jsr MOVFM ; load float into fac1 jsr FOUT ; fac1 to string in A/Y jsr c64.STROUT ; print string in A/Y - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -209,12 +209,12 @@ sub print_f (float value) { sub print_fln (float value) { ; ---- prints the floating point value (with a newline at the end) using basic rom routines %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #value jsr MOVFM ; load float into fac1 jsr FPRINTLN ; print fac1 with newline - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} diff --git a/compiler/res/prog8lib/c64lib.p8 b/compiler/res/prog8lib/c64lib.p8 index d4b2dde49..5f3a6611c 100644 --- a/compiler/res/prog8lib/c64lib.p8 +++ b/compiler/res/prog8lib/c64lib.p8 @@ -7,16 +7,6 @@ c64 { - ; TODO get rid of those: - const uword ESTACK_LO = $ce00 ; evaluation stack (lsb) - const uword ESTACK_HI = $cf00 ; evaluation stack (msb) - &ubyte SCRATCH_ZPB1 = $02 ; scratch byte 1 in ZP - &ubyte SCRATCH_ZPREG = $03 ; scratch register in ZP - &ubyte SCRATCH_ZPREGX = $fa ; temp storage for X register (stack pointer) - &uword SCRATCH_ZPWORD1 = $fb ; scratch word in ZP ($fb/$fc) - &uword SCRATCH_ZPWORD2 = $fd ; scratch word in ZP ($fd/$fe) - - &ubyte TIME_HI = $a0 ; software jiffy clock, hi byte &ubyte TIME_MID = $a1 ; .. mid byte &ubyte TIME_LO = $a2 ; .. lo byte. Updated by IRQ every 1/60 sec diff --git a/compiler/res/prog8lib/c64utils.p8 b/compiler/res/prog8lib/c64utils.p8 index bf9fea306..4b0e11359 100644 --- a/compiler/res/prog8lib/c64utils.p8 +++ b/compiler/res/prog8lib/c64utils.p8 @@ -59,9 +59,9 @@ asmsub uword2decimal (uword value @ AY) -> ubyte @Y, ubyte @A, ubyte @X { ASCII_0_OFFSET = $30 -temp = c64.SCRATCH_ZPB1 ; byte in zeropage -hexHigh = c64.SCRATCH_ZPWORD1 ; byte in zeropage -hexLow = c64.SCRATCH_ZPWORD1+1 ; byte in zeropage +temp = P8ZP_SCRATCH_B1 ; byte in zeropage +hexHigh = P8ZP_SCRATCH_W1 ; byte in zeropage +hexLow = P8ZP_SCRATCH_W1+1 ; byte in zeropage HexToDec65535; SUBROUTINE @@ -221,7 +221,7 @@ asmsub byte2decimal (byte value @ A) -> ubyte @ Y, ubyte @ A, ubyte @ X { asmsub ubyte2hex (ubyte value @ A) -> ubyte @ A, ubyte @ Y { ; ---- A to hex petscii string in AY (first hex char in A, second hex char in Y) %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X pha and #$0f tax @@ -233,7 +233,7 @@ asmsub ubyte2hex (ubyte value @ A) -> ubyte @ A, ubyte @ Y { lsr a tax lda _hex_digits,x - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts _hex_digits .text "0123456789abcdef" ; can probably be reused for other stuff as well @@ -243,12 +243,12 @@ _hex_digits .text "0123456789abcdef" ; can probably be reused for other stuff as asmsub uword2hex (uword value @ AY) clobbers(A,Y) { ; ---- convert 16 bit uword in A/Y into 4-character hexadecimal string 'uword2hex.output' (0-terminated) %asm {{ - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG tya jsr ubyte2hex sta output sty output+1 - lda c64.SCRATCH_ZPREG + lda P8ZP_SCRATCH_REG jsr ubyte2hex sta output+2 sty output+3 @@ -262,7 +262,7 @@ asmsub str2uword(str string @ AY) -> uword @ AY { ; the number may NOT be preceded by a + sign and may NOT contain spaces ; (any non-digit character will terminate the number string that is parsed) %asm {{ -_result = c64.SCRATCH_ZPWORD2 +_result = P8ZP_SCRATCH_W2 sta _mod+1 sty _mod+2 ldy #0 @@ -293,16 +293,16 @@ _done ; return result _result_times_10 ; (W*4 + W)*2 lda _result+1 - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG lda _result asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc adc _result sta _result - lda c64.SCRATCH_ZPREG + lda P8ZP_SCRATCH_REG adc _result+1 asl _result rol a @@ -316,14 +316,14 @@ asmsub str2word(str string @ AY) -> word @ AY { ; the number may be preceded by a + or - sign but may NOT contain spaces ; (any non-digit character will terminate the number string that is parsed) %asm {{ -_result = c64.SCRATCH_ZPWORD2 - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 +_result = P8ZP_SCRATCH_W2 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 ldy #0 sty _result sty _result+1 sty _negative - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp #'+' bne + iny @@ -331,7 +331,7 @@ _result = c64.SCRATCH_ZPWORD2 bne _parse inc _negative iny -_parse lda (c64.SCRATCH_ZPWORD1),y +_parse lda (P8ZP_SCRATCH_W1),y sec sbc #48 bpl _digit @@ -402,19 +402,19 @@ _irq_handler jsr _irq_handler_init _irq_handler_init ; save all zp scratch registers and the X register as these might be clobbered by the irq routine stx IRQ_X_REG - lda c64.SCRATCH_ZPB1 + lda P8ZP_SCRATCH_B1 sta IRQ_SCRATCH_ZPB1 - lda c64.SCRATCH_ZPREG + lda P8ZP_SCRATCH_REG sta IRQ_SCRATCH_ZPREG - lda c64.SCRATCH_ZPREGX + lda P8ZP_SCRATCH_REG_X sta IRQ_SCRATCH_ZPREGX - lda c64.SCRATCH_ZPWORD1 + lda P8ZP_SCRATCH_W1 sta IRQ_SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + lda P8ZP_SCRATCH_W1+1 sta IRQ_SCRATCH_ZPWORD1+1 - lda c64.SCRATCH_ZPWORD2 + lda P8ZP_SCRATCH_W2 sta IRQ_SCRATCH_ZPWORD2 - lda c64.SCRATCH_ZPWORD2+1 + lda P8ZP_SCRATCH_W2+1 sta IRQ_SCRATCH_ZPWORD2+1 ; stack protector; make sure we don't clobber the top of the evaluation stack dex @@ -429,19 +429,19 @@ _irq_handler_init _irq_handler_end ; restore all zp scratch registers and the X register lda IRQ_SCRATCH_ZPB1 - sta c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 lda IRQ_SCRATCH_ZPREG - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG lda IRQ_SCRATCH_ZPREGX - sta c64.SCRATCH_ZPREGX + sta P8ZP_SCRATCH_REG_X lda IRQ_SCRATCH_ZPWORD1 - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 lda IRQ_SCRATCH_ZPWORD1+1 - sta c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1+1 lda IRQ_SCRATCH_ZPWORD2 - sta c64.SCRATCH_ZPWORD2 + sta P8ZP_SCRATCH_W2 lda IRQ_SCRATCH_ZPWORD2+1 - sta c64.SCRATCH_ZPWORD2+1 + sta P8ZP_SCRATCH_W2+1 ldx IRQ_X_REG rts @@ -595,7 +595,7 @@ asmsub scroll_left_full (ubyte alsocolors @ Pc) clobbers(A, Y) { ; Carry flag determines if screen color data must be scrolled too %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X bcs + jmp _scroll_screen @@ -623,7 +623,7 @@ _scroll_screen ; scroll the screen memory dey bpl - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -633,7 +633,7 @@ asmsub scroll_right_full (ubyte alsocolors @ Pc) clobbers(A) { ; contents of the leftmost column are unchanged, you should clear/refill this yourself ; Carry flag determines if screen color data must be scrolled too %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X bcs + jmp _scroll_screen @@ -657,7 +657,7 @@ _scroll_screen ; scroll the screen memory dex bpl - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -667,7 +667,7 @@ asmsub scroll_up_full (ubyte alsocolors @ Pc) clobbers(A) { ; contents of the bottom row are unchanged, you should refill/clear this yourself ; Carry flag determines if screen color data must be scrolled too %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X bcs + jmp _scroll_screen @@ -691,7 +691,7 @@ _scroll_screen ; scroll the screen memory dex bpl - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -701,7 +701,7 @@ asmsub scroll_down_full (ubyte alsocolors @ Pc) clobbers(A) { ; contents of the top row are unchanged, you should refill/clear this yourself ; Carry flag determines if screen color data must be scrolled too %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X bcs + jmp _scroll_screen @@ -725,7 +725,7 @@ _scroll_screen ; scroll the screen memory dex bpl - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -737,10 +737,10 @@ asmsub print (str text @ AY) clobbers(A,Y) { ; a call to this subroutine with a string argument of just one char, ; by just one call to c64.CHROUT of that single char. %asm {{ - sta c64.SCRATCH_ZPB1 - sty c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_B1 + sty P8ZP_SCRATCH_REG ldy #0 -- lda (c64.SCRATCH_ZPB1),y +- lda (P8ZP_SCRATCH_B1),y beq + jsr c64.CHROUT iny @@ -752,7 +752,7 @@ asmsub print (str text @ AY) clobbers(A,Y) { asmsub print_ub0 (ubyte value @ A) clobbers(A,Y) { ; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total) %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr c64utils.ubyte2decimal pha tya @@ -761,7 +761,7 @@ asmsub print_ub0 (ubyte value @ A) clobbers(A,Y) { jsr c64.CHROUT txa jsr c64.CHROUT - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -769,7 +769,7 @@ asmsub print_ub0 (ubyte value @ A) clobbers(A,Y) { asmsub print_ub (ubyte value @ A) clobbers(A,Y) { ; ---- print the ubyte in A in decimal form, without left padding 0s %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr c64utils.ubyte2decimal _print_byte_digits pha @@ -786,7 +786,7 @@ _print_byte_digits jsr c64.CHROUT _ones txa jsr c64.CHROUT - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -794,7 +794,7 @@ _ones txa asmsub print_b (byte value @ A) clobbers(A,Y) { ; ---- print the byte in A in decimal form, without left padding 0s %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X pha cmp #0 bpl + @@ -803,7 +803,7 @@ asmsub print_b (byte value @ A) clobbers(A,Y) { + pla jsr c64utils.byte2decimal jsr print_ub._print_byte_digits - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -811,7 +811,7 @@ asmsub print_b (byte value @ A) clobbers(A,Y) { asmsub print_ubhex (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y) { ; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well) %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X bcc + pha lda #'$' @@ -821,7 +821,7 @@ asmsub print_ubhex (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y) { jsr c64.CHROUT tya jsr c64.CHROUT - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -829,20 +829,20 @@ asmsub print_ubhex (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y) { asmsub print_ubbin (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y) { ; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well) %asm {{ - stx c64.SCRATCH_ZPREGX - sta c64.SCRATCH_ZPB1 + stx P8ZP_SCRATCH_REG_X + sta P8ZP_SCRATCH_B1 bcc + lda #'%' jsr c64.CHROUT + ldy #8 - lda #'0' - asl c64.SCRATCH_ZPB1 + asl P8ZP_SCRATCH_B1 bcc + lda #'1' + jsr c64.CHROUT dey bne - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } @@ -875,7 +875,7 @@ asmsub print_uwhex (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y) { asmsub print_uw0 (uword value @ AY) clobbers(A,Y) { ; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total) %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr c64utils.uword2decimal ldy #0 - lda c64utils.uword2decimal.decTenThousands,y @@ -883,7 +883,7 @@ asmsub print_uw0 (uword value @ AY) clobbers(A,Y) { jsr c64.CHROUT iny bne - -+ ldx c64.SCRATCH_ZPREGX ++ ldx P8ZP_SCRATCH_REG_X rts }} } @@ -891,9 +891,9 @@ asmsub print_uw0 (uword value @ AY) clobbers(A,Y) { asmsub print_uw (uword value @ AY) clobbers(A,Y) { ; ---- print the uword in A/Y in decimal form, without left padding 0s %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X jsr c64utils.uword2decimal - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X ldy #0 - lda c64utils.uword2decimal.decTenThousands,y beq _allzero @@ -940,17 +940,17 @@ asmsub input_chars (uword buffer @ AY) clobbers(A) -> ubyte @ Y { ; It assumes the keyboard is selected as I/O channel! %asm {{ - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 ldy #0 ; char counter = 0 - jsr c64.CHRIN cmp #$0d ; return (ascii 13) pressed? beq + ; yes, end. - sta (c64.SCRATCH_ZPWORD1),y ; else store char in buffer + sta (P8ZP_SCRATCH_W1),y ; else store char in buffer iny bne - + lda #0 - sta (c64.SCRATCH_ZPWORD1),y ; finish string with 0 byte + sta (P8ZP_SCRATCH_W1),y ; finish string with 0 byte rts }} @@ -959,18 +959,18 @@ asmsub input_chars (uword buffer @ AY) clobbers(A) -> ubyte @ Y { asmsub setchr (ubyte col @Y, ubyte row @A) clobbers(A) { ; ---- set the character in SCRATCH_ZPB1 on the screen matrix at the given position %asm {{ - sty c64.SCRATCH_ZPREG + sty P8ZP_SCRATCH_REG asl a tay lda _screenrows+1,y sta _mod+2 lda _screenrows,y clc - adc c64.SCRATCH_ZPREG + adc P8ZP_SCRATCH_REG sta _mod+1 bcc + inc _mod+2 -+ lda c64.SCRATCH_ZPB1 ++ lda P8ZP_SCRATCH_B1 _mod sta $ffff ; modified rts @@ -981,14 +981,14 @@ _screenrows .word $0400 + range(0, 1000, 40) asmsub getchr (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A { ; ---- get the character in the screen matrix at the given location %asm {{ - sty c64.SCRATCH_ZPB1 + sty P8ZP_SCRATCH_B1 asl a tay lda setchr._screenrows+1,y sta _mod+2 lda setchr._screenrows,y clc - adc c64.SCRATCH_ZPB1 + adc P8ZP_SCRATCH_B1 sta _mod+1 bcc _mod inc _mod+2 @@ -1000,18 +1000,18 @@ _mod lda $ffff ; modified asmsub setclr (ubyte col @Y, ubyte row @A) clobbers(A) { ; ---- set the color in SCRATCH_ZPB1 on the screen matrix at the given position %asm {{ - sty c64.SCRATCH_ZPREG + sty P8ZP_SCRATCH_REG asl a tay lda _colorrows+1,y sta _mod+2 lda _colorrows,y clc - adc c64.SCRATCH_ZPREG + adc P8ZP_SCRATCH_REG sta _mod+1 bcc + inc _mod+2 -+ lda c64.SCRATCH_ZPB1 ++ lda P8ZP_SCRATCH_B1 _mod sta $ffff ; modified rts @@ -1022,14 +1022,14 @@ _colorrows .word $d800 + range(0, 1000, 40) asmsub getclr (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A { ; ---- get the color in the screen color matrix at the given location %asm {{ - sty c64.SCRATCH_ZPB1 + sty P8ZP_SCRATCH_B1 asl a tay lda setclr._colorrows+1,y sta _mod+2 lda setclr._colorrows,y clc - adc c64.SCRATCH_ZPB1 + adc P8ZP_SCRATCH_B1 sta _mod+1 bcc _mod inc _mod+2 @@ -1067,11 +1067,11 @@ _colormod sta $ffff ; modified asmsub plot (ubyte col @ Y, ubyte row @ A) clobbers(A) { ; ---- safe wrapper around PLOT kernel routine, to save the X register. %asm {{ - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X tax clc jsr c64.PLOT - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts }} } diff --git a/compiler/res/prog8lib/math.asm b/compiler/res/prog8lib/math.asm index 34237e5a9..3bf166a61 100644 --- a/compiler/res/prog8lib/math.asm +++ b/compiler/res/prog8lib/math.asm @@ -1,4 +1,5 @@ ; Prog8 internal Math library routines - always included by the compiler +; Generic machine independent 6502 code. ; ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0 ; @@ -12,14 +13,14 @@ multiply_bytes .proc ; -- multiply 2 bytes A and Y, result as byte in A (signed or unsigned) - sta c64.SCRATCH_ZPB1 ; num1 - sty c64.SCRATCH_ZPREG ; num2 + sta P8ZP_SCRATCH_B1 ; num1 + sty P8ZP_SCRATCH_REG ; num2 lda #0 beq _enterloop _doAdd clc - adc c64.SCRATCH_ZPB1 -_loop asl c64.SCRATCH_ZPB1 -_enterloop lsr c64.SCRATCH_ZPREG + adc P8ZP_SCRATCH_B1 +_loop asl P8ZP_SCRATCH_B1 +_enterloop lsr P8ZP_SCRATCH_REG bcs _doAdd bne _loop rts @@ -28,49 +29,49 @@ _enterloop lsr c64.SCRATCH_ZPREG multiply_bytes_16 .proc ; -- multiply 2 bytes A and Y, result as word in A/Y (unsigned) - sta c64.SCRATCH_ZPB1 - sty c64.SCRATCH_ZPREG - stx c64.SCRATCH_ZPREGX + sta P8ZP_SCRATCH_B1 + sty P8ZP_SCRATCH_REG + stx P8ZP_SCRATCH_REG_X lda #0 ldx #8 - lsr c64.SCRATCH_ZPB1 + lsr P8ZP_SCRATCH_B1 - bcc + clc - adc c64.SCRATCH_ZPREG + adc P8ZP_SCRATCH_REG + ror a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 dex bne - tay - lda c64.SCRATCH_ZPB1 - ldx c64.SCRATCH_ZPREGX + lda P8ZP_SCRATCH_B1 + ldx P8ZP_SCRATCH_REG_X rts .pend multiply_words .proc ; -- multiply two 16-bit words into a 32-bit result (signed and unsigned) - ; input: A/Y = first 16-bit number, c64.SCRATCH_ZPWORD1 in ZP = second 16-bit number + ; input: A/Y = first 16-bit number, P8ZP_SCRATCH_W1 in ZP = second 16-bit number ; output: multiply_words.result 4-bytes/32-bits product, LSB order (low-to-high) ; clobbers: A - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 - stx c64.SCRATCH_ZPREGX + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 + stx P8ZP_SCRATCH_REG_X mult16 lda #$00 sta result+2 ; clear upper bits of product sta result+3 ldx #16 ; for all 16 bits... -- lsr c64.SCRATCH_ZPWORD1+1 ; divide multiplier by 2 - ror c64.SCRATCH_ZPWORD1 +- lsr P8ZP_SCRATCH_W1+1 ; divide multiplier by 2 + ror P8ZP_SCRATCH_W1 bcc + lda result+2 ; get upper half of product and add multiplicand clc - adc c64.SCRATCH_ZPWORD2 + adc P8ZP_SCRATCH_W2 sta result+2 lda result+3 - adc c64.SCRATCH_ZPWORD2+1 + adc P8ZP_SCRATCH_W2+1 + ror a ; rotate partial product sta result+3 ror result+2 @@ -78,7 +79,7 @@ mult16 lda #$00 ror result dex bne - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts result .byte 0,0,0,0 @@ -88,39 +89,39 @@ result .byte 0,0,0,0 divmod_ub .proc ; -- divide A by Y, result quotient in Y, remainder in A (unsigned) ; division by zero will result in quotient = 255 and remainder = original number - sty c64.SCRATCH_ZPREG - sta c64.SCRATCH_ZPB1 - stx c64.SCRATCH_ZPREGX + sty P8ZP_SCRATCH_REG + sta P8ZP_SCRATCH_B1 + stx P8ZP_SCRATCH_REG_X lda #0 ldx #8 - asl c64.SCRATCH_ZPB1 + asl P8ZP_SCRATCH_B1 - rol a - cmp c64.SCRATCH_ZPREG + cmp P8ZP_SCRATCH_REG bcc + - sbc c64.SCRATCH_ZPREG -+ rol c64.SCRATCH_ZPB1 + sbc P8ZP_SCRATCH_REG ++ rol P8ZP_SCRATCH_B1 dex bne - - ldy c64.SCRATCH_ZPB1 - ldx c64.SCRATCH_ZPREGX + ldy P8ZP_SCRATCH_B1 + ldx P8ZP_SCRATCH_REG_X rts .pend divmod_uw_asm .proc ; -- divide two unsigned words (16 bit each) into 16 bit results - ; input: c64.SCRATCH_ZPWORD1 in ZP: 16 bit number, A/Y: 16 bit divisor - ; output: c64.SCRATCH_ZPWORD2 in ZP: 16 bit remainder, A/Y: 16 bit division result + ; input: P8ZP_SCRATCH_W1 in ZP: 16 bit number, A/Y: 16 bit divisor + ; output: P8ZP_SCRATCH_W2 in ZP: 16 bit remainder, A/Y: 16 bit division result ; division by zero will result in quotient = 65535 and remainder = divident -dividend = c64.SCRATCH_ZPWORD1 -remainder = c64.SCRATCH_ZPWORD2 +dividend = P8ZP_SCRATCH_W1 +remainder = P8ZP_SCRATCH_W2 result = dividend ;save memory by reusing divident to store the result sta _divisor sty _divisor+1 - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda #0 ;preset remainder to 0 sta remainder sta remainder+1 @@ -147,7 +148,7 @@ result = dividend ;save memory by reusing divident to store the result lda result ldy result+1 - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts _divisor .word 0 .pend @@ -233,197 +234,197 @@ _seed .word $2c9e mul_byte_3 .proc ; X + X*2 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_3 .proc ; W*2 + W - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_5 .proc ; X*4 + X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_5 .proc ; W*4 + W - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_6 .proc ; (X*2 + X)*2 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_6 .proc ; (W*2 + W)*2 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - asl c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + asl P8ESTACK_LO+1,x rol a - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_7 .proc ; X*8 - X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a asl a sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_7 .proc ; W*8 - W - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - sbc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + sbc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_9 .proc ; X*8 + X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a asl a clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_9 .proc ; W*8 + W - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_10 .proc ; (X*4 + X)*2 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_10 .proc ; (W*4 + W)*2 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - asl c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + asl P8ESTACK_LO+1,x rol a - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_11 .proc ; (X*2 + X)*4 - X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -431,47 +432,47 @@ mul_byte_11 .proc mul_byte_12 .proc ; (X*2 + X)*4 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_12 .proc ; (W*2 + W)*4 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - asl c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + asl P8ESTACK_LO+1,x rol a - asl c64.ESTACK_LO+1,x + asl P8ESTACK_LO+1,x rol a - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_13 .proc ; (X*2 + X)*4 + X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -479,14 +480,14 @@ mul_byte_13 .proc mul_byte_14 .proc ; (X*8 - X)*2 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a asl a sec - sbc c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -494,191 +495,191 @@ mul_byte_14 .proc mul_byte_15 .proc ; X*16 - X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a asl a asl a sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_15 .proc ; W*16 - W - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - sbc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + sbc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_20 .proc ; (X*4 + X)*4 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_20 .proc ; (W*4 + W)*4 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - asl c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + asl P8ESTACK_LO+1,x rol a - asl c64.ESTACK_LO+1,x + asl P8ESTACK_LO+1,x rol a - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_25 .proc ; (X*2 + X)*8 + X - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a asl a clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_25 .proc ; W + W*8 + W*16 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPWORD1+1 + rol P8ZP_SCRATCH_W1+1 asl a - rol c64.SCRATCH_ZPWORD1+1 + rol P8ZP_SCRATCH_W1+1 asl a - rol c64.SCRATCH_ZPWORD1+1 - sta c64.SCRATCH_ZPWORD1 + rol P8ZP_SCRATCH_W1+1 + sta P8ZP_SCRATCH_W1 clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPWORD1+1 - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x - lda c64.SCRATCH_ZPWORD1 + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_W1+1 + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x + lda P8ZP_SCRATCH_W1 asl a - rol c64.SCRATCH_ZPWORD1+1 + rol P8ZP_SCRATCH_W1+1 clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPWORD1+1 - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_W1+1 + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend mul_byte_40 .proc ; (X*4 + X)*8 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x asl a asl a clc - adc c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x asl a asl a asl a - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word_40 .proc ; (W*4 + W)*8 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPREG - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_REG + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG asl a - rol c64.SCRATCH_ZPREG + rol P8ZP_SCRATCH_REG clc - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPREG - adc c64.ESTACK_HI+1,x - asl c64.ESTACK_LO+1,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_REG + adc P8ESTACK_HI+1,x + asl P8ESTACK_LO+1,x rol a - asl c64.ESTACK_LO+1,x + asl P8ESTACK_LO+1,x rol a - asl c64.ESTACK_LO+1,x + asl P8ESTACK_LO+1,x rol a - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend sign_b .proc - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x beq _sign_zero bmi _sign_neg _sign_pos lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _sign_neg lda #-1 -_sign_zero sta c64.ESTACK_LO+1,x +_sign_zero sta P8ESTACK_LO+1,x rts .pend sign_ub .proc - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x beq sign_b._sign_zero bne sign_b._sign_pos .pend sign_w .proc - lda c64.ESTACK_HI+1,x + lda P8ESTACK_HI+1,x bmi sign_b._sign_neg beq sign_ub bne sign_b._sign_pos .pend sign_uw .proc - lda c64.ESTACK_HI+1,x + lda P8ESTACK_HI+1,x beq _sign_possibly_zero _sign_pos lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts -_sign_possibly_zero lda c64.ESTACK_LO+1,x +_sign_possibly_zero lda P8ESTACK_LO+1,x bne _sign_pos - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -688,185 +689,185 @@ _sign_possibly_zero lda c64.ESTACK_LO+1,x ; anything below 3 is done inline. anything above 7 is done via other optimizations. shift_left_w_7 .proc - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 _shift6 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 _shift5 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 _shift4 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 _shift3 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 asl a - rol c64.SCRATCH_ZPB1 + rol P8ZP_SCRATCH_B1 - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_HI+1,x + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_HI+1,x rts .pend shift_left_w_6 .proc - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x jmp shift_left_w_7._shift6 .pend shift_left_w_5 .proc - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x jmp shift_left_w_7._shift5 .pend shift_left_w_4 .proc - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x jmp shift_left_w_7._shift4 .pend shift_left_w_3 .proc - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x jmp shift_left_w_7._shift3 .pend shift_right_uw_7 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_HI+1,x lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 _shift6 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 _shift5 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 _shift4 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 _shift3 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 lsr a - ror c64.SCRATCH_ZPB1 + ror P8ZP_SCRATCH_B1 - sta c64.ESTACK_HI+1,x - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_HI+1,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_LO+1,x rts .pend shift_right_uw_6 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_HI+1,x jmp shift_right_uw_7._shift6 .pend shift_right_uw_5 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_HI+1,x jmp shift_right_uw_7._shift5 .pend shift_right_uw_4 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_HI+1,x jmp shift_right_uw_7._shift4 .pend shift_right_uw_3 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + lda P8ESTACK_HI+1,x jmp shift_right_uw_7._shift3 .pend shift_right_w_7 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 - lda c64.SCRATCH_ZPWORD1+1 + lda P8ZP_SCRATCH_W1+1 _shift6 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 _shift5 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 _shift4 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 _shift3 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 - lda c64.SCRATCH_ZPWORD1+1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 + lda P8ZP_SCRATCH_W1+1 asl a - ror c64.SCRATCH_ZPWORD1+1 - ror c64.SCRATCH_ZPWORD1 + ror P8ZP_SCRATCH_W1+1 + ror P8ZP_SCRATCH_W1 - lda c64.SCRATCH_ZPWORD1 - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPWORD1+1 - sta c64.ESTACK_HI+1,x + lda P8ZP_SCRATCH_W1 + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_W1+1 + sta P8ESTACK_HI+1,x rts .pend shift_right_w_6 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 jmp shift_right_w_7._shift6 .pend shift_right_w_5 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 jmp shift_right_w_7._shift5 .pend shift_right_w_4 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 jmp shift_right_w_7._shift4 .pend shift_right_w_3 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 jmp shift_right_w_7._shift3 .pend diff --git a/compiler/res/prog8lib/prog8lib.asm b/compiler/res/prog8lib/prog8lib.asm index 7e2bf72fe..f281756ab 100644 --- a/compiler/res/prog8lib/prog8lib.asm +++ b/compiler/res/prog8lib/prog8lib.asm @@ -1,10 +1,12 @@ ; Prog8 internal library routines - always included by the compiler +; Generic machine independent 6502 code. ; ; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0 ; ; indent format: TABS, size=8 +; TODO move this one to c64lib: init_system .proc ; -- initializes the machine to a sane starting state ; Called automatically by the loader program logic. @@ -38,263 +40,263 @@ init_system .proc read_byte_from_address_on_stack .proc ; -- read the byte from the memory address on the top of the stack, return in A (stack remains unchanged) - lda c64.ESTACK_LO+1,x - ldy c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 + lda P8ESTACK_LO+1,x + ldy P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 ldy #0 - lda (c64.SCRATCH_ZPWORD2),y + lda (P8ZP_SCRATCH_W2),y rts .pend write_byte_to_address_on_stack .proc ; -- write the byte in A to the memory address on the top of the stack (stack remains unchanged) - ldy c64.ESTACK_LO+1,x - sty c64.SCRATCH_ZPWORD2 - ldy c64.ESTACK_HI+1,x - sty c64.SCRATCH_ZPWORD2+1 + ldy P8ESTACK_LO+1,x + sty P8ZP_SCRATCH_W2 + ldy P8ESTACK_HI+1,x + sty P8ZP_SCRATCH_W2+1 ldy #0 - sta (c64.SCRATCH_ZPWORD2),y + sta (P8ZP_SCRATCH_W2),y rts .pend add_a_to_zpword .proc - ; -- add ubyte in A to the uword in c64.SCRATCH_ZPWORD1 + ; -- add ubyte in A to the uword in P8ZP_SCRATCH_W1 clc - adc c64.SCRATCH_ZPWORD1 - sta c64.SCRATCH_ZPWORD1 + adc P8ZP_SCRATCH_W1 + sta P8ZP_SCRATCH_W1 bcc + - inc c64.SCRATCH_ZPWORD1+1 + inc P8ZP_SCRATCH_W1+1 + rts .pend pop_index_times_5 .proc inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a asl a clc - adc c64.ESTACK_LO,x + adc P8ESTACK_LO,x rts .pend neg_b .proc lda #0 sec - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend neg_w .proc sec lda #0 - sbc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda #0 - sbc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + sbc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend inv_word .proc - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x eor #255 - sta c64.ESTACK_LO+1,x - lda c64.ESTACK_HI+1,x + sta P8ESTACK_LO+1,x + lda P8ESTACK_HI+1,x eor #255 - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend not_byte .proc - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x beq + lda #1 + eor #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend not_word .proc - lda c64.ESTACK_LO + 1,x - ora c64.ESTACK_HI + 1,x + lda P8ESTACK_LO + 1,x + ora P8ESTACK_HI + 1,x beq + lda #1 + eor #1 - sta c64.ESTACK_LO + 1,x + sta P8ESTACK_LO + 1,x lsr a - sta c64.ESTACK_HI + 1,x + sta P8ESTACK_HI + 1,x rts .pend bitand_b .proc ; -- bitwise and (of 2 bytes) - lda c64.ESTACK_LO+2,x - and c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + and P8ESTACK_LO+1,x inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend bitor_b .proc ; -- bitwise or (of 2 bytes) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_LO+1,x inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend bitxor_b .proc ; -- bitwise xor (of 2 bytes) - lda c64.ESTACK_LO+2,x - eor c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + eor P8ESTACK_LO+1,x inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend bitand_w .proc ; -- bitwise and (of 2 words) - lda c64.ESTACK_LO+2,x - and c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+2,x - lda c64.ESTACK_HI+2,x - and c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+2,x + lda P8ESTACK_LO+2,x + and P8ESTACK_LO+1,x + sta P8ESTACK_LO+2,x + lda P8ESTACK_HI+2,x + and P8ESTACK_HI+1,x + sta P8ESTACK_HI+2,x inx rts .pend bitor_w .proc ; -- bitwise or (of 2 words) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+2,x - lda c64.ESTACK_HI+2,x - ora c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+2,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_LO+1,x + sta P8ESTACK_LO+2,x + lda P8ESTACK_HI+2,x + ora P8ESTACK_HI+1,x + sta P8ESTACK_HI+2,x inx rts .pend bitxor_w .proc ; -- bitwise xor (of 2 bytes) - lda c64.ESTACK_LO+2,x - eor c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+2,x - lda c64.ESTACK_HI+2,x - eor c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+2,x + lda P8ESTACK_LO+2,x + eor P8ESTACK_LO+1,x + sta P8ESTACK_LO+2,x + lda P8ESTACK_HI+2,x + eor P8ESTACK_HI+1,x + sta P8ESTACK_HI+2,x inx rts .pend and_b .proc ; -- logical and (of 2 bytes) - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x beq + lda #1 -+ sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x ++ sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x beq + lda #1 -+ and c64.SCRATCH_ZPB1 ++ and P8ZP_SCRATCH_B1 inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend or_b .proc ; -- logical or (of 2 bytes) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_LO+1,x beq + lda #1 + inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend xor_b .proc ; -- logical xor (of 2 bytes) - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x beq + lda #1 -+ sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x ++ sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x beq + lda #1 -+ eor c64.SCRATCH_ZPB1 ++ eor P8ZP_SCRATCH_B1 inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend and_w .proc ; -- logical and (word and word -> byte) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_HI+2,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_HI+2,x beq + lda #1 -+ sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x - ora c64.ESTACK_HI+1,x ++ sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x + ora P8ESTACK_HI+1,x beq + lda #1 -+ and c64.SCRATCH_ZPB1 ++ and P8ZP_SCRATCH_B1 inx - sta c64.ESTACK_LO+1,x - sta c64.ESTACK_HI+1,x + sta P8ESTACK_LO+1,x + sta P8ESTACK_HI+1,x rts .pend or_w .proc ; -- logical or (word or word -> byte) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_LO+1,x - ora c64.ESTACK_HI+2,x - ora c64.ESTACK_HI+1,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_LO+1,x + ora P8ESTACK_HI+2,x + ora P8ESTACK_HI+1,x beq + lda #1 + inx - sta c64.ESTACK_LO+1,x - sta c64.ESTACK_HI+1,x + sta P8ESTACK_LO+1,x + sta P8ESTACK_HI+1,x rts .pend xor_w .proc ; -- logical xor (word xor word -> byte) - lda c64.ESTACK_LO+2,x - ora c64.ESTACK_HI+2,x + lda P8ESTACK_LO+2,x + ora P8ESTACK_HI+2,x beq + lda #1 -+ sta c64.SCRATCH_ZPB1 - lda c64.ESTACK_LO+1,x - ora c64.ESTACK_HI+1,x ++ sta P8ZP_SCRATCH_B1 + lda P8ESTACK_LO+1,x + ora P8ESTACK_HI+1,x beq + lda #1 -+ eor c64.SCRATCH_ZPB1 ++ eor P8ZP_SCRATCH_B1 inx - sta c64.ESTACK_LO+1,x - sta c64.ESTACK_HI+1,x + sta P8ESTACK_LO+1,x + sta P8ESTACK_HI+1,x rts .pend abs_b .proc ; -- push abs(byte) on stack (as byte) - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x bmi neg_b rts .pend abs_w .proc ; -- push abs(word) on stack (as word) - lda c64.ESTACK_HI+1,x + lda P8ESTACK_HI+1,x bmi neg_w rts .pend @@ -303,12 +305,12 @@ add_w .proc ; -- push word+word / uword+uword inx clc - lda c64.ESTACK_LO,x - adc c64.ESTACK_LO+1,x - sta c64.ESTACK_LO+1,x - lda c64.ESTACK_HI,x - adc c64.ESTACK_HI+1,x - sta c64.ESTACK_HI+1,x + lda P8ESTACK_LO,x + adc P8ESTACK_LO+1,x + sta P8ESTACK_LO+1,x + lda P8ESTACK_HI,x + adc P8ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend @@ -316,55 +318,55 @@ sub_w .proc ; -- push word-word inx sec - lda c64.ESTACK_LO+1,x - sbc c64.ESTACK_LO,x - sta c64.ESTACK_LO+1,x - lda c64.ESTACK_HI+1,x - sbc c64.ESTACK_HI,x - sta c64.ESTACK_HI+1,x + lda P8ESTACK_LO+1,x + sbc P8ESTACK_LO,x + sta P8ESTACK_LO+1,x + lda P8ESTACK_HI+1,x + sbc P8ESTACK_HI,x + sta P8ESTACK_HI+1,x rts .pend mul_byte .proc ; -- b*b->b (signed and unsigned) inx - lda c64.ESTACK_LO,x - ldy c64.ESTACK_LO+1,x + lda P8ESTACK_LO,x + ldy P8ESTACK_LO+1,x jsr math.multiply_bytes - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend mul_word .proc inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO+1,x - ldy c64.ESTACK_HI+1,x + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO+1,x + ldy P8ESTACK_HI+1,x jsr math.multiply_words lda math.multiply_words.result - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda math.multiply_words.result+1 - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend idiv_b .proc ; signed division: use unsigned division and fix sign of result afterwards inx - lda c64.ESTACK_LO,x - eor c64.ESTACK_LO+1,x + lda P8ESTACK_LO,x + eor P8ESTACK_LO+1,x php ; save sign of result - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x bpl + eor #$ff sec adc #0 ; make num1 positive + tay inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x bpl + eor #$ff sec @@ -377,7 +379,7 @@ idiv_b .proc eor #$ff sec adc #0 ; negate result -+ sta c64.ESTACK_LO,x ++ sta P8ESTACK_LO,x dex rts _remainder .byte 0 @@ -385,36 +387,36 @@ _remainder .byte 0 idiv_ub .proc inx - ldy c64.ESTACK_LO,x - lda c64.ESTACK_LO+1,x + ldy P8ESTACK_LO,x + lda P8ESTACK_LO+1,x jsr math.divmod_ub tya - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend idiv_w .proc ; signed division: use unsigned division and fix sign of result afterwards - lda c64.ESTACK_HI+2,x - eor c64.ESTACK_HI+1,x + lda P8ESTACK_HI+2,x + eor P8ESTACK_HI+1,x php ; save sign of result - lda c64.ESTACK_HI+1,x + lda P8ESTACK_HI+1,x bpl + jsr neg_w ; make value positive + inx - lda c64.ESTACK_HI+1,x + lda P8ESTACK_HI+1,x bpl + jsr neg_w ; make value positive -+ lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO,x - ldy c64.ESTACK_HI,x ++ lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO,x + ldy P8ESTACK_HI,x jsr math.divmod_uw_asm - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x tya - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x plp bpl + jmp neg_w ; negate result @@ -423,83 +425,83 @@ idiv_w .proc idiv_uw .proc inx - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO,x - ldy c64.ESTACK_HI,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO,x + ldy P8ESTACK_HI,x jsr math.divmod_uw_asm - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x tya - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend remainder_ub .proc inx - ldy c64.ESTACK_LO,x ; right operand - lda c64.ESTACK_LO+1,x ; left operand + ldy P8ESTACK_LO,x ; right operand + lda P8ESTACK_LO+1,x ; left operand jsr math.divmod_ub - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend remainder_uw .proc inx - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO,x - ldy c64.ESTACK_HI,x + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO,x + ldy P8ESTACK_HI,x jsr math.divmod_uw_asm - lda c64.SCRATCH_ZPWORD2 - sta c64.ESTACK_LO+1,x - lda c64.SCRATCH_ZPWORD2+1 - sta c64.ESTACK_HI+1,x + lda P8ZP_SCRATCH_W2 + sta P8ESTACK_LO+1,x + lda P8ZP_SCRATCH_W2+1 + sta P8ESTACK_HI+1,x rts .pend equal_w .proc ; -- are the two words on the stack identical? - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x bne equal_b._equal_b_false - lda c64.ESTACK_HI+1,x - cmp c64.ESTACK_HI+2,x + lda P8ESTACK_HI+1,x + cmp P8ESTACK_HI+2,x bne equal_b._equal_b_false beq equal_b._equal_b_true .pend notequal_b .proc ; -- are the two bytes on the stack different? - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x beq equal_b._equal_b_false bne equal_b._equal_b_true .pend notequal_w .proc ; -- are the two words on the stack different? - lda c64.ESTACK_HI+1,x - cmp c64.ESTACK_HI+2,x + lda P8ESTACK_HI+1,x + cmp P8ESTACK_HI+2,x beq notequal_b bne equal_b._equal_b_true .pend less_ub .proc - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x bcc equal_b._equal_b_true bcs equal_b._equal_b_false .pend less_b .proc ; see http://www.6502.org/tutorials/compare_beyond.html - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x sec - sbc c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x bvc + eor #$80 + bmi equal_b._equal_b_true @@ -507,21 +509,21 @@ less_b .proc .pend less_uw .proc - lda c64.ESTACK_HI+2,x - cmp c64.ESTACK_HI+1,x + lda P8ESTACK_HI+2,x + cmp P8ESTACK_HI+1,x bcc equal_b._equal_b_true bne equal_b._equal_b_false - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x bcc equal_b._equal_b_true bcs equal_b._equal_b_false .pend less_w .proc - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x - lda c64.ESTACK_HI+2,x - sbc c64.ESTACK_HI+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x + lda P8ESTACK_HI+2,x + sbc P8ESTACK_HI+1,x bvc + eor #$80 + bmi equal_b._equal_b_true @@ -530,29 +532,29 @@ less_w .proc equal_b .proc ; -- are the two bytes on the stack identical? - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x bne _equal_b_false _equal_b_true lda #1 _equal_b_store inx - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _equal_b_false lda #0 beq _equal_b_store .pend lesseq_ub .proc - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x bcs equal_b._equal_b_true bcc equal_b._equal_b_false .pend lesseq_b .proc ; see http://www.6502.org/tutorials/compare_beyond.html - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x clc - sbc c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x bvc + eor #$80 + bmi equal_b._equal_b_true @@ -560,21 +562,21 @@ lesseq_b .proc .pend lesseq_uw .proc - lda c64.ESTACK_HI+1,x - cmp c64.ESTACK_HI+2,x + lda P8ESTACK_HI+1,x + cmp P8ESTACK_HI+2,x bcc equal_b._equal_b_false bne equal_b._equal_b_true - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x bcs equal_b._equal_b_true bcc equal_b._equal_b_false .pend lesseq_w .proc - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x - lda c64.ESTACK_HI+1,x - sbc c64.ESTACK_HI+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x + lda P8ESTACK_HI+1,x + sbc P8ESTACK_HI+2,x bvc + eor #$80 + bpl equal_b._equal_b_true @@ -582,8 +584,8 @@ lesseq_w .proc .pend greater_ub .proc - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x beq equal_b._equal_b_false bcs equal_b._equal_b_true bcc equal_b._equal_b_false @@ -591,9 +593,9 @@ greater_ub .proc greater_b .proc ; see http://www.6502.org/tutorials/compare_beyond.html - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x clc - sbc c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x bvc + eor #$80 + bpl equal_b._equal_b_true @@ -601,21 +603,21 @@ greater_b .proc .pend greater_uw .proc - lda c64.ESTACK_HI+1,x - cmp c64.ESTACK_HI+2,x + lda P8ESTACK_HI+1,x + cmp P8ESTACK_HI+2,x bcc equal_b._equal_b_true bne equal_b._equal_b_false - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x bcc equal_b._equal_b_true bcs equal_b._equal_b_false .pend greater_w .proc - lda c64.ESTACK_LO+1,x - cmp c64.ESTACK_LO+2,x - lda c64.ESTACK_HI+1,x - sbc c64.ESTACK_HI+2,x + lda P8ESTACK_LO+1,x + cmp P8ESTACK_LO+2,x + lda P8ESTACK_HI+1,x + sbc P8ESTACK_HI+2,x bvc + eor #$80 + bmi equal_b._equal_b_true @@ -623,17 +625,17 @@ greater_w .proc .pend greatereq_ub .proc - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x bcs equal_b._equal_b_true bcc equal_b._equal_b_false .pend greatereq_b .proc ; see http://www.6502.org/tutorials/compare_beyond.html - lda c64.ESTACK_LO+2,x + lda P8ESTACK_LO+2,x sec - sbc c64.ESTACK_LO+1,x + sbc P8ESTACK_LO+1,x bvc + eor #$80 + bpl equal_b._equal_b_true @@ -641,21 +643,21 @@ greatereq_b .proc .pend greatereq_uw .proc - lda c64.ESTACK_HI+2,x - cmp c64.ESTACK_HI+1,x + lda P8ESTACK_HI+2,x + cmp P8ESTACK_HI+1,x bcc equal_b._equal_b_false bne equal_b._equal_b_true - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x bcs equal_b._equal_b_true bcc equal_b._equal_b_false .pend greatereq_w .proc - lda c64.ESTACK_LO+2,x - cmp c64.ESTACK_LO+1,x - lda c64.ESTACK_HI+2,x - sbc c64.ESTACK_HI+1,x + lda P8ESTACK_LO+2,x + cmp P8ESTACK_LO+1,x + lda P8ESTACK_HI+2,x + sbc P8ESTACK_HI+1,x bvc + eor #$80 + bpl equal_b._equal_b_true @@ -665,27 +667,27 @@ greatereq_w .proc shiftleft_b .proc inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x bne + rts -+ lda c64.ESTACK_LO+1,x ++ lda P8ESTACK_LO+1,x - asl a dey bne - - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend shiftright_b .proc inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x bne + rts -+ lda c64.ESTACK_LO+1,x ++ lda P8ESTACK_LO+1,x - lsr a dey bne - - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend @@ -694,7 +696,7 @@ orig_stackpointer .byte 0 ; stores the Stack pointer register at program start func_exit .proc ; -- immediately exit the program with a return code in the A register - lda c64.ESTACK_LO+1,x + lda P8ESTACK_LO+1,x ldx orig_stackpointer txs rts ; return to original caller @@ -705,84 +707,84 @@ func_read_flags .proc ; -- put the processor status register on the stack php pla - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend func_sqrt16 .proc - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD2 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD2+1 - stx c64.SCRATCH_ZPREGX + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W2 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W2+1 + stx P8ZP_SCRATCH_REG_X ldy #$00 ; r = 0 ldx #$07 clc ; clear bit 16 of m _loop tya ora _stab-1,x - sta c64.SCRATCH_ZPB1 ; (r asl 8) | (d asl 7) - lda c64.SCRATCH_ZPWORD2+1 + sta P8ZP_SCRATCH_B1 ; (r asl 8) | (d asl 7) + lda P8ZP_SCRATCH_W2+1 bcs _skip0 ; m >= 65536? then t <= m is always true - cmp c64.SCRATCH_ZPB1 + cmp P8ZP_SCRATCH_B1 bcc _skip1 ; t <= m _skip0 - sbc c64.SCRATCH_ZPB1 - sta c64.SCRATCH_ZPWORD2+1 ; m = m - t + sbc P8ZP_SCRATCH_B1 + sta P8ZP_SCRATCH_W2+1 ; m = m - t tya ora _stab,x tay ; r = r or d _skip1 - asl c64.SCRATCH_ZPWORD2 - rol c64.SCRATCH_ZPWORD2+1 ; m = m asl 1 + asl P8ZP_SCRATCH_W2 + rol P8ZP_SCRATCH_W2+1 ; m = m asl 1 dex bne _loop ; last iteration bcs _skip2 - sty c64.SCRATCH_ZPB1 - lda c64.SCRATCH_ZPWORD2 + sty P8ZP_SCRATCH_B1 + lda P8ZP_SCRATCH_W2 cmp #$80 - lda c64.SCRATCH_ZPWORD2+1 - sbc c64.SCRATCH_ZPB1 + lda P8ZP_SCRATCH_W2+1 + sbc P8ZP_SCRATCH_B1 bcc _skip3 _skip2 iny ; r = r or d (d is 1 here) _skip3 - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X tya - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda #0 - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts _stab .byte $01,$02,$04,$08,$10,$20,$40,$80 .pend func_sin8 .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda _sinecos8,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _sinecos8 .char trunc(127.0 * sin(range(256+64) * rad(360.0/256.0))) .pend func_sin8u .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda _sinecos8u,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _sinecos8u .byte trunc(128.0 + 127.5 * sin(range(256+64) * rad(360.0/256.0))) .pend func_sin16 .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda _sinecos8lo,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda _sinecos8hi,y - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts _ := trunc(32767.0 * sin(range(256+64) * rad(360.0/256.0))) @@ -791,11 +793,11 @@ _sinecos8hi .byte >_ .pend func_sin16u .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda _sinecos8ulo,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda _sinecos8uhi,y - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts _ := trunc(32768.0 + 32767.5 * sin(range(256+64) * rad(360.0/256.0))) @@ -804,129 +806,129 @@ _sinecos8uhi .byte >_ .pend func_cos8 .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda func_sin8._sinecos8+64,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend func_cos8u .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda func_sin8u._sinecos8u+64,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend func_cos16 .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda func_sin16._sinecos8lo+64,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda func_sin16._sinecos8hi+64,y - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend func_cos16u .proc - ldy c64.ESTACK_LO+1,x + ldy P8ESTACK_LO+1,x lda func_sin16u._sinecos8ulo+64,y - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x lda func_sin16u._sinecos8uhi+64,y - sta c64.ESTACK_HI+1,x + sta P8ESTACK_HI+1,x rts .pend peek_address .proc - ; -- peek address on stack into c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + ; -- peek address on stack into P8ZP_SCRATCH_W1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 rts .pend func_any_b .proc inx - lda c64.ESTACK_LO,x ; array size + lda P8ESTACK_LO,x ; array size _entry sta _cmp_mod+1 ; self-modifying code jsr peek_address ldy #0 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y bne _got_any iny _cmp_mod cpy #255 ; modified bne - lda #0 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _got_any lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend func_any_w .proc inx - lda c64.ESTACK_LO,x ; array size + lda P8ESTACK_LO,x ; array size asl a ; times 2 because of word jmp func_any_b._entry .pend func_all_b .proc inx - lda c64.ESTACK_LO,x ; array size + lda P8ESTACK_LO,x ; array size sta _cmp_mod+1 ; self-modifying code jsr peek_address ldy #0 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y beq _got_not_all iny _cmp_mod cpy #255 ; modified bne - lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts _got_not_all lda #0 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend func_all_w .proc inx - lda c64.ESTACK_LO,x ; array size + lda P8ESTACK_LO,x ; array size asl a ; times 2 because of word sta _cmp_mod+1 ; self-modifying code jsr peek_address ldy #0 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y bne + iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y bne ++ lda #0 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts + iny + iny _cmp_mod cpy #255 ; modified bne - lda #1 - sta c64.ESTACK_LO+1,x + sta P8ESTACK_LO+1,x rts .pend func_max_ub .proc jsr pop_array_and_lengthmin1Y lda #0 - sta c64.SCRATCH_ZPB1 -- lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 +- lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_B1 bcc + - sta c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 + dey cpy #255 bne - - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_LO,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_LO,x dex rts .pend @@ -934,20 +936,20 @@ func_max_ub .proc func_max_b .proc jsr pop_array_and_lengthmin1Y lda #-128 - sta c64.SCRATCH_ZPB1 -- lda (c64.SCRATCH_ZPWORD1),y + sta P8ZP_SCRATCH_B1 +- lda (P8ZP_SCRATCH_W1),y sec - sbc c64.SCRATCH_ZPB1 + sbc P8ZP_SCRATCH_B1 bvc + eor #$80 + bmi + - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPB1 + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_B1 + dey cpy #255 bne - - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_LO,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_LO,x dex rts .pend @@ -962,18 +964,18 @@ func_max_uw .proc tay _loop iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey cmp _result_maxuw+1 bcc _lesseq bne _greater - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp _result_maxuw bcc _lesseq -_greater lda (c64.SCRATCH_ZPWORD1),y +_greater lda (P8ZP_SCRATCH_W1),y sta _result_maxuw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_maxuw+1 dey _lesseq dey @@ -981,9 +983,9 @@ _lesseq dey cpy #254 bne _loop lda _result_maxuw - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x lda _result_maxuw+1 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x dex rts _result_maxuw .word 0 @@ -999,19 +1001,19 @@ func_max_w .proc asl a tay _loop - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp _result_maxw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey sbc _result_maxw+1 bvc + eor #$80 + bmi _lesseq - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_maxw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_maxw+1 dey _lesseq dey @@ -1019,9 +1021,9 @@ _lesseq dey cpy #254 bne _loop lda _result_maxw - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x lda _result_maxw+1 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x dex rts _result_maxw .word 0 @@ -1031,20 +1033,20 @@ _result_maxw .word 0 func_sum_b .proc jsr pop_array_and_lengthmin1Y lda #0 - sta c64.ESTACK_LO,x - sta c64.ESTACK_HI,x -_loop lda (c64.SCRATCH_ZPWORD1),y + sta P8ESTACK_LO,x + sta P8ESTACK_HI,x +_loop lda (P8ZP_SCRATCH_W1),y pha clc - adc c64.ESTACK_LO,x - sta c64.ESTACK_LO,x + adc P8ESTACK_LO,x + sta P8ESTACK_LO,x ; sign extend the high byte pla and #$80 beq + lda #$ff -+ adc c64.ESTACK_HI,x - sta c64.ESTACK_HI,x ++ adc P8ESTACK_HI,x + sta P8ESTACK_HI,x dey cpy #255 bne _loop @@ -1055,15 +1057,15 @@ _loop lda (c64.SCRATCH_ZPWORD1),y func_sum_ub .proc jsr pop_array_and_lengthmin1Y lda #0 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x - clc - adc (c64.SCRATCH_ZPWORD1),y + adc (P8ZP_SCRATCH_W1),y bcc + - inc c64.ESTACK_HI,x + inc P8ESTACK_HI,x + dey cpy #255 bne - - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend @@ -1074,16 +1076,16 @@ func_sum_uw .proc asl a tay lda #0 - sta c64.ESTACK_LO,x - sta c64.ESTACK_HI,x -- lda (c64.SCRATCH_ZPWORD1),y + sta P8ESTACK_LO,x + sta P8ESTACK_HI,x +- lda (P8ZP_SCRATCH_W1),y iny clc - adc c64.ESTACK_LO,x - sta c64.ESTACK_LO,x - lda (c64.SCRATCH_ZPWORD1),y - adc c64.ESTACK_HI,x - sta c64.ESTACK_HI,x + adc P8ESTACK_LO,x + sta P8ESTACK_LO,x + lda (P8ZP_SCRATCH_W1),y + adc P8ESTACK_HI,x + sta P8ESTACK_HI,x dey dey dey @@ -1100,12 +1102,12 @@ func_sum_w .proc pop_array_and_lengthmin1Y .proc inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x dey ; length minus 1, for iteration - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W1+1 inx rts .pend @@ -1113,16 +1115,16 @@ pop_array_and_lengthmin1Y .proc func_min_ub .proc jsr pop_array_and_lengthmin1Y lda #255 - sta c64.SCRATCH_ZPB1 -- lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 +- lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_B1 bcs + - sta c64.SCRATCH_ZPB1 + sta P8ZP_SCRATCH_B1 + dey cpy #255 bne - - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_LO,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_LO,x dex rts .pend @@ -1131,20 +1133,20 @@ func_min_ub .proc func_min_b .proc jsr pop_array_and_lengthmin1Y lda #127 - sta c64.SCRATCH_ZPB1 -- lda (c64.SCRATCH_ZPWORD1),y + sta P8ZP_SCRATCH_B1 +- lda (P8ZP_SCRATCH_W1),y clc - sbc c64.SCRATCH_ZPB1 + sbc P8ZP_SCRATCH_B1 bvc + eor #$80 + bpl + - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPB1 + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_B1 + dey cpy #255 bne - - lda c64.SCRATCH_ZPB1 - sta c64.ESTACK_LO,x + lda P8ZP_SCRATCH_B1 + sta P8ESTACK_LO,x dex rts .pend @@ -1159,18 +1161,18 @@ func_min_uw .proc tay _loop iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey cmp _result_minuw+1 bcc _less bne _gtequ - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp _result_minuw bcs _gtequ -_less lda (c64.SCRATCH_ZPWORD1),y +_less lda (P8ZP_SCRATCH_W1),y sta _result_minuw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_minuw+1 dey _gtequ dey @@ -1178,9 +1180,9 @@ _gtequ dey cpy #254 bne _loop lda _result_minuw - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x lda _result_minuw+1 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x dex rts _result_minuw .word 0 @@ -1196,19 +1198,19 @@ func_min_w .proc asl a tay _loop - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp _result_minw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey sbc _result_minw+1 bvc + eor #$80 + bpl _gtequ - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_minw iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _result_minw+1 dey _gtequ dey @@ -1216,9 +1218,9 @@ _gtequ dey cpy #254 bne _loop lda _result_minw - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x lda _result_minw+1 - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x dex rts _result_minw .word 0 @@ -1227,7 +1229,7 @@ _result_minw .word 0 func_rnd .proc ; -- put a random ubyte on the estack jsr math.randbyte - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x dex rts .pend @@ -1235,9 +1237,9 @@ func_rnd .proc func_rndw .proc ; -- put a random uword on the estack jsr math.randword - sta c64.ESTACK_LO,x + sta P8ESTACK_LO,x tya - sta c64.ESTACK_HI,x + sta P8ESTACK_HI,x dex rts .pend @@ -1246,24 +1248,24 @@ func_rndw .proc func_memcopy .proc ; note: clobbers A,Y inx - stx c64.SCRATCH_ZPREGX - lda c64.ESTACK_LO+2,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+2,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD2 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD2+1 - lda c64.ESTACK_LO,x + stx P8ZP_SCRATCH_REG_X + lda P8ESTACK_LO+2,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+2,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W2 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W2+1 + lda P8ESTACK_LO,x tax ldy #0 -- lda (c64.SCRATCH_ZPWORD1), y - sta (c64.SCRATCH_ZPWORD2), y +- lda (P8ZP_SCRATCH_W1), y + sta (P8ZP_SCRATCH_W2), y iny dex bne - - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X inx inx rts @@ -1272,18 +1274,18 @@ func_memcopy .proc func_memset .proc ; note: clobbers A,Y inx - stx c64.SCRATCH_ZPREGX - lda c64.ESTACK_LO+2,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+2,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPB1 - ldy c64.ESTACK_HI+1,x - lda c64.ESTACK_LO,x - ldx c64.SCRATCH_ZPB1 + stx P8ZP_SCRATCH_REG_X + lda P8ESTACK_LO+2,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+2,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_B1 + ldy P8ESTACK_HI+1,x + lda P8ESTACK_LO,x + ldx P8ZP_SCRATCH_B1 jsr memset - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X inx inx rts @@ -1294,19 +1296,19 @@ func_memsetw .proc ; -- fill memory from (SCRATCH_ZPWORD1) number of words in SCRATCH_ZPWORD2, with word value in AY. inx - stx c64.SCRATCH_ZPREGX - lda c64.ESTACK_LO+2,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+2,x - sta c64.SCRATCH_ZPWORD1+1 - lda c64.ESTACK_LO+1,x - sta c64.SCRATCH_ZPWORD2 - lda c64.ESTACK_HI+1,x - sta c64.SCRATCH_ZPWORD2+1 - lda c64.ESTACK_LO,x - ldy c64.ESTACK_HI,x + stx P8ZP_SCRATCH_REG_X + lda P8ESTACK_LO+2,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+2,x + sta P8ZP_SCRATCH_W1+1 + lda P8ESTACK_LO+1,x + sta P8ZP_SCRATCH_W2 + lda P8ESTACK_HI+1,x + sta P8ZP_SCRATCH_W2+1 + lda P8ESTACK_LO,x + ldy P8ESTACK_HI,x jsr memsetw - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X inx inx rts @@ -1314,10 +1316,10 @@ func_memsetw .proc strlen .proc ; -- put length of 0-terminated string in A/Y into A - sta c64.SCRATCH_ZPWORD1 - sty c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1 + sty P8ZP_SCRATCH_W1+1 ldy #0 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y beq + iny bne - @@ -1329,9 +1331,9 @@ strlen .proc memcopy16_up .proc ; -- copy memory UP from (SCRATCH_ZPWORD1) to (SCRATCH_ZPWORD2) of length X/Y (16-bit, X=lo, Y=hi) ; clobbers register A,X,Y - source = c64.SCRATCH_ZPWORD1 - dest = c64.SCRATCH_ZPWORD2 - length = c64.SCRATCH_ZPB1 ; (and SCRATCH_ZPREG) + source = P8ZP_SCRATCH_W1 + dest = P8ZP_SCRATCH_W2 + length = P8ZP_SCRATCH_B1 ; (and SCRATCH_ZPREG) stx length sty length+1 @@ -1357,23 +1359,23 @@ memcopy16_up .proc memset .proc ; -- fill memory from (SCRATCH_ZPWORD1), length XY, with value in A. ; clobbers X, Y - stx c64.SCRATCH_ZPB1 - sty c64.SCRATCH_ZPREG + stx P8ZP_SCRATCH_B1 + sty P8ZP_SCRATCH_REG ldy #0 - ldx c64.SCRATCH_ZPREG + ldx P8ZP_SCRATCH_REG beq _lastpage -_fullpage sta (c64.SCRATCH_ZPWORD1),y +_fullpage sta (P8ZP_SCRATCH_W1),y iny bne _fullpage - inc c64.SCRATCH_ZPWORD1+1 ; next page + inc P8ZP_SCRATCH_W1+1 ; next page dex bne _fullpage -_lastpage ldy c64.SCRATCH_ZPB1 +_lastpage ldy P8ZP_SCRATCH_B1 beq + - dey - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y bne - + rts @@ -1387,48 +1389,48 @@ memsetw .proc sty _mod1b+1 ; self-modify sta _mod2+1 ; self-modify sty _mod2b+1 ; self-modify - ldx c64.SCRATCH_ZPWORD1 - stx c64.SCRATCH_ZPB1 - ldx c64.SCRATCH_ZPWORD1+1 + ldx P8ZP_SCRATCH_W1 + stx P8ZP_SCRATCH_B1 + ldx P8ZP_SCRATCH_W1+1 inx - stx c64.SCRATCH_ZPREG ; second page + stx P8ZP_SCRATCH_REG ; second page ldy #0 - ldx c64.SCRATCH_ZPWORD2+1 + ldx P8ZP_SCRATCH_W2+1 beq _lastpage _fullpage _mod1 lda #0 ; self-modified - sta (c64.SCRATCH_ZPWORD1),y ; first page - sta (c64.SCRATCH_ZPB1),y ; second page + sta (P8ZP_SCRATCH_W1),y ; first page + sta (P8ZP_SCRATCH_B1),y ; second page iny _mod1b lda #0 ; self-modified - sta (c64.SCRATCH_ZPWORD1),y ; first page - sta (c64.SCRATCH_ZPB1),y ; second page + sta (P8ZP_SCRATCH_W1),y ; first page + sta (P8ZP_SCRATCH_B1),y ; second page iny bne _fullpage - inc c64.SCRATCH_ZPWORD1+1 ; next page pair - inc c64.SCRATCH_ZPWORD1+1 ; next page pair - inc c64.SCRATCH_ZPB1+1 ; next page pair - inc c64.SCRATCH_ZPB1+1 ; next page pair + inc P8ZP_SCRATCH_W1+1 ; next page pair + inc P8ZP_SCRATCH_W1+1 ; next page pair + inc P8ZP_SCRATCH_B1+1 ; next page pair + inc P8ZP_SCRATCH_B1+1 ; next page pair dex bne _fullpage -_lastpage ldx c64.SCRATCH_ZPWORD2 +_lastpage ldx P8ZP_SCRATCH_W2 beq _done ldy #0 - _mod2 lda #0 ; self-modified - sta (c64.SCRATCH_ZPWORD1), y - inc c64.SCRATCH_ZPWORD1 + sta (P8ZP_SCRATCH_W1), y + inc P8ZP_SCRATCH_W1 bne _mod2b - inc c64.SCRATCH_ZPWORD1+1 + inc P8ZP_SCRATCH_W1+1 _mod2b lda #0 ; self-modified - sta (c64.SCRATCH_ZPWORD1), y - inc c64.SCRATCH_ZPWORD1 + sta (P8ZP_SCRATCH_W1), y + inc P8ZP_SCRATCH_W1 bne + - inc c64.SCRATCH_ZPWORD1+1 + inc P8ZP_SCRATCH_W1+1 + dex bne - _done rts @@ -1438,31 +1440,31 @@ _done rts sort_ub .proc ; 8bit unsigned sort ; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int) - ; input: address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1 + ; input: address of array to sort in P8ZP_SCRATCH_W1, length in P8ZP_SCRATCH_B1 ; first, put pointer BEFORE array - lda c64.SCRATCH_ZPWORD1 + lda P8ZP_SCRATCH_W1 bne + - dec c64.SCRATCH_ZPWORD1+1 -+ dec c64.SCRATCH_ZPWORD1 -_sortloop ldy c64.SCRATCH_ZPB1 ;start of subroutine sort - lda (c64.SCRATCH_ZPWORD1),y ;last value in (what is left of) sequence to be sorted - sta c64.SCRATCH_ZPREG ;save value. will be over-written by largest number + dec P8ZP_SCRATCH_W1+1 ++ dec P8ZP_SCRATCH_W1 +_sortloop ldy P8ZP_SCRATCH_B1 ;start of subroutine sort + lda (P8ZP_SCRATCH_W1),y ;last value in (what is left of) sequence to be sorted + sta P8ZP_SCRATCH_REG ;save value. will be over-written by largest number jmp _l2 _l1 dey beq _l3 - lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPWORD2+1 + lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_W2+1 bcc _l1 -_l2 sty c64.SCRATCH_ZPWORD2 ;index of potentially largest value - sta c64.SCRATCH_ZPWORD2+1 ;potentially largest value +_l2 sty P8ZP_SCRATCH_W2 ;index of potentially largest value + sta P8ZP_SCRATCH_W2+1 ;potentially largest value jmp _l1 -_l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put - lda c64.SCRATCH_ZPWORD2+1 ;the largest value - sta (c64.SCRATCH_ZPWORD1),y ;put largest value in place - ldy c64.SCRATCH_ZPWORD2 ;index of free space - lda c64.SCRATCH_ZPREG ;the over-written value - sta (c64.SCRATCH_ZPWORD1),y ;put the over-written value in the free space - dec c64.SCRATCH_ZPB1 ;end of the shorter sequence still left +_l3 ldy P8ZP_SCRATCH_B1 ;where the largest value shall be put + lda P8ZP_SCRATCH_W2+1 ;the largest value + sta (P8ZP_SCRATCH_W1),y ;put largest value in place + ldy P8ZP_SCRATCH_W2 ;index of free space + lda P8ZP_SCRATCH_REG ;the over-written value + sta (P8ZP_SCRATCH_W1),y ;put the over-written value in the free space + dec P8ZP_SCRATCH_B1 ;end of the shorter sequence still left bne _sortloop ;start working with the shorter sequence rts .pend @@ -1471,31 +1473,31 @@ _l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put sort_b .proc ; 8bit signed sort ; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int) - ; input: address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1 + ; input: address of array to sort in P8ZP_SCRATCH_W1, length in P8ZP_SCRATCH_B1 ; first, put pointer BEFORE array - lda c64.SCRATCH_ZPWORD1 + lda P8ZP_SCRATCH_W1 bne + - dec c64.SCRATCH_ZPWORD1+1 -+ dec c64.SCRATCH_ZPWORD1 -_sortloop ldy c64.SCRATCH_ZPB1 ;start of subroutine sort - lda (c64.SCRATCH_ZPWORD1),y ;last value in (what is left of) sequence to be sorted - sta c64.SCRATCH_ZPREG ;save value. will be over-written by largest number + dec P8ZP_SCRATCH_W1+1 ++ dec P8ZP_SCRATCH_W1 +_sortloop ldy P8ZP_SCRATCH_B1 ;start of subroutine sort + lda (P8ZP_SCRATCH_W1),y ;last value in (what is left of) sequence to be sorted + sta P8ZP_SCRATCH_REG ;save value. will be over-written by largest number jmp _l2 _l1 dey beq _l3 - lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPWORD2+1 + lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_W2+1 bmi _l1 -_l2 sty c64.SCRATCH_ZPWORD2 ;index of potentially largest value - sta c64.SCRATCH_ZPWORD2+1 ;potentially largest value +_l2 sty P8ZP_SCRATCH_W2 ;index of potentially largest value + sta P8ZP_SCRATCH_W2+1 ;potentially largest value jmp _l1 -_l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put - lda c64.SCRATCH_ZPWORD2+1 ;the largest value - sta (c64.SCRATCH_ZPWORD1),y ;put largest value in place - ldy c64.SCRATCH_ZPWORD2 ;index of free space - lda c64.SCRATCH_ZPREG ;the over-written value - sta (c64.SCRATCH_ZPWORD1),y ;put the over-written value in the free space - dec c64.SCRATCH_ZPB1 ;end of the shorter sequence still left +_l3 ldy P8ZP_SCRATCH_B1 ;where the largest value shall be put + lda P8ZP_SCRATCH_W2+1 ;the largest value + sta (P8ZP_SCRATCH_W1),y ;put largest value in place + ldy P8ZP_SCRATCH_W2 ;index of free space + lda P8ZP_SCRATCH_REG ;the over-written value + sta (P8ZP_SCRATCH_W1),y ;put the over-written value in the free space + dec P8ZP_SCRATCH_B1 ;end of the shorter sequence still left bne _sortloop ;start working with the shorter sequence rts .pend @@ -1504,20 +1506,20 @@ _l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put sort_uw .proc ; 16bit unsigned sort ; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int) - ; input: address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1 + ; input: address of array to sort in P8ZP_SCRATCH_W1, length in P8ZP_SCRATCH_B1 ; first: subtract 2 of the pointer - asl c64.SCRATCH_ZPB1 ; *2 because words - lda c64.SCRATCH_ZPWORD1 + asl P8ZP_SCRATCH_B1 ; *2 because words + lda P8ZP_SCRATCH_W1 sec sbc #2 - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 bcs _sort_loop - dec c64.SCRATCH_ZPWORD1+1 -_sort_loop ldy c64.SCRATCH_ZPB1 ;start of subroutine sort - lda (c64.SCRATCH_ZPWORD1),y ;last value in (what is left of) sequence to be sorted + dec P8ZP_SCRATCH_W1+1 +_sort_loop ldy P8ZP_SCRATCH_B1 ;start of subroutine sort + lda (P8ZP_SCRATCH_W1),y ;last value in (what is left of) sequence to be sorted sta _work3 ;save value. will be over-written by largest number iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _work3+1 dey jmp _l2 @@ -1525,36 +1527,36 @@ _l1 dey dey beq _l3 iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey - cmp c64.SCRATCH_ZPWORD2+1 + cmp P8ZP_SCRATCH_W2+1 bne + - lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPWORD2 + lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_W2 + bcc _l1 _l2 sty _work1 ;index of potentially largest value - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPWORD2 ;potentially largest value + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_W2 ;potentially largest value iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPWORD2+1 + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_W2+1 dey jmp _l1 -_l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put - lda c64.SCRATCH_ZPWORD2 ;the largest value - sta (c64.SCRATCH_ZPWORD1),y ;put largest value in place +_l3 ldy P8ZP_SCRATCH_B1 ;where the largest value shall be put + lda P8ZP_SCRATCH_W2 ;the largest value + sta (P8ZP_SCRATCH_W1),y ;put largest value in place iny - lda c64.SCRATCH_ZPWORD2+1 - sta (c64.SCRATCH_ZPWORD1),y + lda P8ZP_SCRATCH_W2+1 + sta (P8ZP_SCRATCH_W1),y ldy _work1 ;index of free space lda _work3 ;the over-written value - sta (c64.SCRATCH_ZPWORD1),y ;put the over-written value in the free space + sta (P8ZP_SCRATCH_W1),y ;put the over-written value in the free space iny lda _work3+1 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey - dec c64.SCRATCH_ZPB1 ;end of the shorter sequence still left - dec c64.SCRATCH_ZPB1 + dec P8ZP_SCRATCH_B1 ;end of the shorter sequence still left + dec P8ZP_SCRATCH_B1 bne _sort_loop ;start working with the shorter sequence rts _work1 .byte 0 @@ -1565,58 +1567,58 @@ _work3 .word 0 sort_w .proc ; 16bit signed sort ; sorting subroutine coded by mats rosengren (mats.rosengren@esa.int) - ; input: address of array to sort in c64.SCRATCH_ZPWORD1, length in c64.SCRATCH_ZPB1 + ; input: address of array to sort in P8ZP_SCRATCH_W1, length in P8ZP_SCRATCH_B1 ; first: subtract 2 of the pointer - asl c64.SCRATCH_ZPB1 ; *2 because words - lda c64.SCRATCH_ZPWORD1 + asl P8ZP_SCRATCH_B1 ; *2 because words + lda P8ZP_SCRATCH_W1 sec sbc #2 - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 bcs _sort_loop - dec c64.SCRATCH_ZPWORD1+1 -_sort_loop ldy c64.SCRATCH_ZPB1 ;start of subroutine sort - lda (c64.SCRATCH_ZPWORD1),y ;last value in (what is left of) sequence to be sorted + dec P8ZP_SCRATCH_W1+1 +_sort_loop ldy P8ZP_SCRATCH_B1 ;start of subroutine sort + lda (P8ZP_SCRATCH_W1),y ;last value in (what is left of) sequence to be sorted sta _work3 ;save value. will be over-written by largest number iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y sta _work3+1 dey jmp _l2 _l1 dey dey beq _l3 - lda (c64.SCRATCH_ZPWORD1),y - cmp c64.SCRATCH_ZPWORD2 + lda (P8ZP_SCRATCH_W1),y + cmp P8ZP_SCRATCH_W2 iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y dey - sbc c64.SCRATCH_ZPWORD2+1 + sbc P8ZP_SCRATCH_W2+1 bvc + eor #$80 + bmi _l1 _l2 sty _work1 ;index of potentially largest value - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPWORD2 ;potentially largest value + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_W2 ;potentially largest value iny - lda (c64.SCRATCH_ZPWORD1),y - sta c64.SCRATCH_ZPWORD2+1 + lda (P8ZP_SCRATCH_W1),y + sta P8ZP_SCRATCH_W2+1 dey jmp _l1 -_l3 ldy c64.SCRATCH_ZPB1 ;where the largest value shall be put - lda c64.SCRATCH_ZPWORD2 ;the largest value - sta (c64.SCRATCH_ZPWORD1),y ;put largest value in place +_l3 ldy P8ZP_SCRATCH_B1 ;where the largest value shall be put + lda P8ZP_SCRATCH_W2 ;the largest value + sta (P8ZP_SCRATCH_W1),y ;put largest value in place iny - lda c64.SCRATCH_ZPWORD2+1 - sta (c64.SCRATCH_ZPWORD1),y + lda P8ZP_SCRATCH_W2+1 + sta (P8ZP_SCRATCH_W1),y ldy _work1 ;index of free space lda _work3 ;the over-written value - sta (c64.SCRATCH_ZPWORD1),y ;put the over-written value in the free space + sta (P8ZP_SCRATCH_W1),y ;put the over-written value in the free space iny lda _work3+1 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey - dec c64.SCRATCH_ZPB1 ;end of the shorter sequence still left - dec c64.SCRATCH_ZPB1 + dec P8ZP_SCRATCH_B1 ;end of the shorter sequence still left + dec P8ZP_SCRATCH_B1 bne _sort_loop ;start working with the shorter sequence rts _work1 .byte 0 @@ -1626,10 +1628,10 @@ _work3 .word 0 reverse_b .proc ; --- reverse an array of bytes (in-place) - ; inputs: pointer to array in c64.SCRATCH_ZPWORD1, length in A -_index_right = c64.SCRATCH_ZPWORD2 -_index_left = c64.SCRATCH_ZPWORD2+1 -_loop_count = c64.SCRATCH_ZPREG + ; inputs: pointer to array in P8ZP_SCRATCH_W1, length in A +_index_right = P8ZP_SCRATCH_W2 +_index_left = P8ZP_SCRATCH_W2+1 +_loop_count = P8ZP_SCRATCH_REG sta _loop_count lsr _loop_count sec @@ -1638,15 +1640,15 @@ _loop_count = c64.SCRATCH_ZPREG lda #0 sta _index_left _loop ldy _index_right - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha ldy _index_left - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _index_right - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y pla ldy _index_left - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _index_left dec _index_right dec _loop_count @@ -1657,15 +1659,15 @@ _loop ldy _index_right reverse_f .proc ; --- reverse an array of floats -_left_index = c64.SCRATCH_ZPWORD2 -_right_index = c64.SCRATCH_ZPWORD2+1 -_loop_count = c64.SCRATCH_ZPREG +_left_index = P8ZP_SCRATCH_W2 +_right_index = P8ZP_SCRATCH_W2+1 +_loop_count = P8ZP_SCRATCH_REG pha - sta c64.SCRATCH_ZPREG + sta P8ZP_SCRATCH_REG asl a asl a clc - adc c64.SCRATCH_ZPREG ; *5 because float + adc P8ZP_SCRATCH_REG ; *5 because float sec sbc #5 sta _right_index @@ -1676,65 +1678,65 @@ _loop_count = c64.SCRATCH_ZPREG sta _loop_count _loop ; push the left indexed float on the stack ldy _left_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha ; copy right index float to left index float ldy _right_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _left_index - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _left_index inc _right_index ldy _right_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _left_index - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _left_index inc _right_index ldy _right_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _left_index - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _left_index inc _right_index ldy _right_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _left_index - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _left_index inc _right_index ldy _right_index - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _left_index - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y ; pop the float off the stack into the right index float ldy _right_index pla - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey pla - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey pla - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey pla - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey pla - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _left_index lda _right_index sec @@ -1749,10 +1751,10 @@ _loop ; push the left indexed float on the stack reverse_w .proc ; --- reverse an array of words (in-place) - ; inputs: pointer to array in c64.SCRATCH_ZPWORD1, length in A -_index_first = c64.SCRATCH_ZPWORD2 -_index_second = c64.SCRATCH_ZPWORD2+1 -_loop_count = c64.SCRATCH_ZPREG + ; inputs: pointer to array in P8ZP_SCRATCH_W1, length in A +_index_first = P8ZP_SCRATCH_W2 +_index_second = P8ZP_SCRATCH_W2+1 +_loop_count = P8ZP_SCRATCH_REG pha asl a ; *2 because words sec @@ -1766,15 +1768,15 @@ _loop_count = c64.SCRATCH_ZPREG sta _loop_count ; first reverse the lsbs _loop_lo ldy _index_first - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha ldy _index_second - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _index_first - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y pla ldy _index_second - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y inc _index_second inc _index_second dec _index_first @@ -1789,15 +1791,15 @@ _loop_lo ldy _index_first pla sta _loop_count _loop_hi ldy _index_first - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y pha ldy _index_second - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ldy _index_first - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y pla ldy _index_second - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dec _index_second dec _index_second inc _index_first @@ -1811,46 +1813,46 @@ _loop_hi ldy _index_first ror2_mem_ub .proc ; -- in-place 8-bit ror of byte at memory location on stack inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 ldy #0 - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y lsr a bcc + ora #$80 -+ sta (c64.SCRATCH_ZPWORD1),y ++ sta (P8ZP_SCRATCH_W1),y rts .pend rol2_mem_ub .proc ; -- in-place 8-bit rol of byte at memory location on stack inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 ldy #0 - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y cmp #$80 rol a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend rol_array_ub .proc ; -- rol a ubyte in an array (index and array address on stack) inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 + lda (P8ZP_SCRATCH_W1),y rol a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend @@ -1858,48 +1860,48 @@ rol_array_ub .proc ror_array_ub .proc ; -- ror a ubyte in an array (index and array address on stack) inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 + lda (P8ZP_SCRATCH_W1),y ror a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend ror2_array_ub .proc ; -- ror2 (8-bit ror) a ubyte in an array (index and array address on stack) inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 + lda (P8ZP_SCRATCH_W1),y lsr a bcc + ora #$80 -+ sta (c64.SCRATCH_ZPWORD1),y ++ sta (P8ZP_SCRATCH_W1),y rts .pend rol2_array_ub .proc ; -- rol2 (8-bit rol) a ubyte in an array (index and array address on stack) inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 + lda (P8ZP_SCRATCH_W1),y cmp #$80 rol a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend @@ -1907,23 +1909,23 @@ ror_array_uw .proc ; -- ror a uword in an array (index and array address on stack) php inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a tay inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y plp ror a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ror a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend @@ -1931,75 +1933,75 @@ rol_array_uw .proc ; -- rol a uword in an array (index and array address on stack) php inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a tay inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + 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 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y rol a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y rts .pend rol2_array_uw .proc ; -- rol2 (16-bit rol) a uword in an array (index and array address on stack) inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a tay inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 - lda (c64.SCRATCH_ZPWORD1),y + 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 (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y rol a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y bcc + dey - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y adc #0 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y + rts .pend ror2_array_uw .proc ; -- ror2 (16-bit ror) a uword in an array (index and array address on stack) inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x asl a tay inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y lsr a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y dey - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ror a - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y bcc + iny - lda (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W1),y ora #$80 - sta (c64.SCRATCH_ZPWORD1),y + sta (P8ZP_SCRATCH_W1),y + rts .pend @@ -2007,12 +2009,12 @@ ror2_array_uw .proc strcpy .proc ; copy a string (0-terminated) from A/Y to (ZPWORD1) ; it is assumed the target string is large enough. - sta c64.SCRATCH_ZPWORD2 - sty c64.SCRATCH_ZPWORD2+1 + sta P8ZP_SCRATCH_W2 + sty P8ZP_SCRATCH_W2+1 ldy #$ff - iny - lda (c64.SCRATCH_ZPWORD2),y - sta (c64.SCRATCH_ZPWORD1),y + lda (P8ZP_SCRATCH_W2),y + sta (P8ZP_SCRATCH_W1),y bne - rts .pend @@ -2021,26 +2023,26 @@ strcpy .proc func_leftstr .proc ; leftstr(source, target, length) with params on stack inx - lda c64.ESTACK_LO,x + lda P8ESTACK_LO,x tay ; length inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD2 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD2+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W2 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W2+1 inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 lda #0 - sta (c64.SCRATCH_ZPWORD2),y + sta (P8ZP_SCRATCH_W2),y - dey cpy #$ff bne + rts -+ lda (c64.SCRATCH_ZPWORD1),y - sta (c64.SCRATCH_ZPWORD2),y ++ lda (P8ZP_SCRATCH_W1),y + sta (P8ZP_SCRATCH_W2),y jmp - .pend @@ -2061,28 +2063,28 @@ func_rightstr .proc ; x+6 -> original targetLO + HI ; x+7 -> original sourceLO + HI ; replicate paramters: - lda c64.ESTACK_LO+5,x - sta c64.ESTACK_LO+1,x - lda c64.ESTACK_LO+6,x - sta c64.ESTACK_LO+3,x - lda c64.ESTACK_HI+6,x - sta c64.ESTACK_HI+3,x - lda c64.ESTACK_LO+7,x - sta c64.ESTACK_LO+4,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI+7,x - sta c64.ESTACK_HI+4,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO+5,x + sta P8ESTACK_LO+1,x + lda P8ESTACK_LO+6,x + sta P8ESTACK_LO+3,x + lda P8ESTACK_HI+6,x + sta P8ESTACK_HI+3,x + lda P8ESTACK_LO+7,x + sta P8ESTACK_LO+4,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI+7,x + sta P8ESTACK_HI+4,x + sta P8ZP_SCRATCH_W1+1 ; determine string length ldy #0 -- lda (c64.SCRATCH_ZPWORD1),y +- lda (P8ZP_SCRATCH_W1),y beq + iny bne - + tya sec - sbc c64.ESTACK_LO+1,x ; start index = strlen - segment length - sta c64.ESTACK_LO+2,x + sbc P8ESTACK_LO+1,x ; start index = strlen - segment length + sta P8ESTACK_LO+2,x jsr func_substr ; unwind original params inx @@ -2094,32 +2096,32 @@ func_rightstr .proc func_substr .proc ; substr(source, target, start, length) with params on stack inx - ldy c64.ESTACK_LO,x ; length + ldy P8ESTACK_LO,x ; length inx - lda c64.ESTACK_LO,x ; start - sta c64.SCRATCH_ZPB1 + lda P8ESTACK_LO,x ; start + sta P8ZP_SCRATCH_B1 inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD2 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD2+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W2 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W2+1 inx - lda c64.ESTACK_LO,x - sta c64.SCRATCH_ZPWORD1 - lda c64.ESTACK_HI,x - sta c64.SCRATCH_ZPWORD1+1 + lda P8ESTACK_LO,x + sta P8ZP_SCRATCH_W1 + lda P8ESTACK_HI,x + sta P8ZP_SCRATCH_W1+1 ; adjust src location clc - lda c64.SCRATCH_ZPWORD1 - adc c64.SCRATCH_ZPB1 - sta c64.SCRATCH_ZPWORD1 + lda P8ZP_SCRATCH_W1 + adc P8ZP_SCRATCH_B1 + sta P8ZP_SCRATCH_W1 bcc + - inc c64.SCRATCH_ZPWORD1+1 + inc P8ZP_SCRATCH_W1+1 + lda #0 - sta (c64.SCRATCH_ZPWORD2),y + sta (P8ZP_SCRATCH_W2),y jmp _startloop -- lda (c64.SCRATCH_ZPWORD1),y - sta (c64.SCRATCH_ZPWORD2),y +- lda (P8ZP_SCRATCH_W1),y + sta (P8ZP_SCRATCH_W2),y _startloop dey cpy #$ff bne - diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt index 6d5352fa5..75cc82088 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt @@ -18,7 +18,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg val sub = stmt.target.targetSubroutine(program.namespace) ?: throw AssemblyError("undefined subroutine ${stmt.target}") val saveX = CpuRegister.X in sub.asmClobbers || sub.regXasResult() if(saveX) - asmgen.out(" stx c64.SCRATCH_ZPREGX") // we only save X for now (required! is the eval stack pointer), screw A and Y... + asmgen.out(" stx P8ZP_SCRATCH_REG_X") // we only save X for now (required! is the eval stack pointer), screw A and Y... val subName = asmgen.asmIdentifierName(stmt.target) if(stmt.args.isNotEmpty()) { @@ -57,7 +57,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg asmgen.out(" jsr $subName") if(saveX) - asmgen.out(" ldx c64.SCRATCH_ZPREGX") // restore X again + asmgen.out(" ldx P8ZP_SCRATCH_REG_X") // restore X again } private fun registerArgsViaStackEvaluation(stmt: IFunctionCall, sub: Subroutine) { diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt index 7a48311ab..b9f26600b 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt @@ -617,9 +617,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, // TODO what about the optimized routines? asmgen.out(""" lda $name - sta c64.SCRATCH_ZPWORD1 + sta P8ZP_SCRATCH_W1 lda $name+1 - sta c64.SCRATCH_ZPWORD1+1 + sta P8ZP_SCRATCH_W1+1 lda #<$value ldy #>$value jsr math.multiply_words @@ -801,7 +801,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, asmgen.translateExpression(value) asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - asl $name rol $name+1 @@ -814,7 +814,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, if(dt==DataType.UWORD) { asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - lsr $name+1 ror $name @@ -824,7 +824,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, else { asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - lda $name+1 asl a @@ -891,7 +891,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, asmgen.translateExpression(value) asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - asl $name dey @@ -903,7 +903,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, if(dt==DataType.UBYTE) { asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - lsr $name dey @@ -912,7 +912,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program, } else { asmgen.out(""" inx - ldy c64.ESTACK_LO,x + ldy P8ESTACK_LO,x beq + - lda $name asl a diff --git a/examples/c64graphics.p8 b/examples/c64graphics.p8 index 3bd9c287d..ad464688b 100644 --- a/examples/c64graphics.p8 +++ b/examples/c64graphics.p8 @@ -186,11 +186,11 @@ graphics { asmsub plot(ubyte ploty @A) { ; plotx is 16 bits 0 to 319... doesn't fit in a register %asm {{ tay - stx c64.SCRATCH_ZPREGX + stx P8ZP_SCRATCH_REG_X lda plotx+1 - sta c64.SCRATCH_ZPWORD2+1 + sta P8ZP_SCRATCH_W2+1 lsr a ; 0 - sta c64.SCRATCH_ZPWORD2 + sta P8ZP_SCRATCH_W2 lda plotx pha and #7 @@ -198,20 +198,20 @@ graphics { lda _y_lookup_lo,y clc - adc c64.SCRATCH_ZPWORD2 - sta c64.SCRATCH_ZPWORD2 + adc P8ZP_SCRATCH_W2 + sta P8ZP_SCRATCH_W2 lda _y_lookup_hi,y - adc c64.SCRATCH_ZPWORD2+1 - sta c64.SCRATCH_ZPWORD2+1 + adc P8ZP_SCRATCH_W2+1 + sta P8ZP_SCRATCH_W2+1 pla ; plotx and #%11111000 tay - lda (c64.SCRATCH_ZPWORD2),y + lda (P8ZP_SCRATCH_W2),y ora _ormask,x - sta (c64.SCRATCH_ZPWORD2),y + sta (P8ZP_SCRATCH_W2),y - ldx c64.SCRATCH_ZPREGX + ldx P8ZP_SCRATCH_REG_X rts _ormask .byte 128, 64, 32, 16, 8, 4, 2, 1