diff --git a/codeCore/src/prog8/code/target/c128/C128Zeropage.kt b/codeCore/src/prog8/code/target/c128/C128Zeropage.kt index de6b0f139..15bda59d6 100644 --- a/codeCore/src/prog8/code/target/c128/C128Zeropage.kt +++ b/codeCore/src/prog8/code/target/c128/C128Zeropage.kt @@ -18,6 +18,8 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) { init { if (options.floats) { throw InternalCompilerException("C128 target doesn't yet support floating point routines") + // note: in git commit labeled 'c128: remove floats module' the floats.p8 and floats.asm files are removed, + // they could be retrieved again at a later time if the compiler somehow *does* store the fp variables in bank1. } if (options.floats && options.zeropage !in arrayOf( diff --git a/compiler/res/prog8lib/c128/floats.asm b/compiler/res/prog8lib/c128/floats.asm deleted file mode 100644 index cd60909d9..000000000 --- a/compiler/res/prog8lib/c128/floats.asm +++ /dev/null @@ -1,664 +0,0 @@ -; --- low level floating point assembly routines for the C128 -; these are almost all identical to the C64 except for a few details -; so we have to have a separate library file for the C128 unfortunately. - - -FL_ONE_const .byte 129 ; 1.0 -FL_ZERO_const .byte 0,0,0,0,0 ; 0.0 -FL_LOG2_const .byte $80, $31, $72, $17, $f8 ; log(2) - - -floats_store_reg .byte 0 ; temp storage - - -ub2float .proc - ; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y - ; clobbers A, Y - stx P8ZP_SCRATCH_REG - sta P8ZP_SCRATCH_W2 - sty P8ZP_SCRATCH_W2+1 - ldy P8ZP_SCRATCH_B1 - lda #0 - jsr GIVAYF -_fac_to_mem ldx P8ZP_SCRATCH_W2 - ldy P8ZP_SCRATCH_W2+1 - jsr MOVMF - ldx P8ZP_SCRATCH_REG - rts - .pend - -b2float .proc - ; -- convert byte in SCRATCH_ZPB1 to float at address A/Y - ; clobbers A, Y - stx P8ZP_SCRATCH_REG - 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 P8ZP_SCRATCH_REG - 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 P8ZP_SCRATCH_REG - 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 - - -cast_from_uw .proc - ; -- uword in A/Y into float var at (P8ZP_SCRATCH_W2) - stx P8ZP_SCRATCH_REG - jsr GIVUAYFAY - jmp ub2float._fac_to_mem - .pend - - -cast_from_w .proc - ; -- word in A/Y into float var at (P8ZP_SCRATCH_W2) - stx P8ZP_SCRATCH_REG - jsr GIVAYFAY - jmp ub2float._fac_to_mem - .pend - - -cast_from_ub .proc - ; -- ubyte in Y into float var at (P8ZP_SCRATCH_W2) - stx P8ZP_SCRATCH_REG - jsr FREADUY - jmp ub2float._fac_to_mem - .pend - - -cast_from_b .proc - ; -- byte in A into float var at (P8ZP_SCRATCH_W2) - stx P8ZP_SCRATCH_REG - jsr FREADSA - jmp ub2float._fac_to_mem - .pend - -cast_as_uw_into_ya .proc ; also used for float 2 ub - ; -- cast float at A/Y to uword into Y/A - jsr MOVFM - jmp cast_FAC1_as_uw_into_ya - .pend - -cast_as_w_into_ay .proc ; also used for float 2 b - ; -- cast float at A/Y to word into A/Y - jsr MOVFM - jmp cast_FAC1_as_w_into_ay - .pend - -cast_FAC1_as_uw_into_ya .proc ; also used for float 2 ub - ; -- cast fac1 to uword into Y/A - stx P8ZP_SCRATCH_REG - jsr GETADR ; into Y/A - ldx P8ZP_SCRATCH_REG - rts - .pend - -cast_FAC1_as_w_into_ay .proc ; also used for float 2 b - ; -- cast fac1 to word into A/Y - stx P8ZP_SCRATCH_REG - jsr AYINT - ldy floats.AYINT_facmo - lda floats.AYINT_facmo+1 - ldx P8ZP_SCRATCH_REG - rts - .pend - - -stack_b2float .proc - ; -- b2float operating on the stack - inx - lda P8ESTACK_LO,x - stx P8ZP_SCRATCH_REG - jsr FREADSA - jmp push_fac1._internal - .pend - -stack_w2float .proc - ; -- w2float operating on the stack - inx - ldy P8ESTACK_LO,x - lda P8ESTACK_HI,x - stx P8ZP_SCRATCH_REG - jsr GIVAYF - jmp push_fac1._internal - .pend - -stack_ub2float .proc - ; -- ub2float operating on the stack - inx - lda P8ESTACK_LO,x - stx P8ZP_SCRATCH_REG - tay - lda #0 - jsr GIVAYF - jmp push_fac1._internal - .pend - -stack_uw2float .proc - ; -- uw2float operating on the stack - inx - lda P8ESTACK_LO,x - ldy P8ESTACK_HI,x - stx P8ZP_SCRATCH_REG - jsr GIVUAYFAY - jmp push_fac1._internal - .pend - -stack_float2w .proc ; also used for float2b - jsr pop_float_fac1 - stx P8ZP_SCRATCH_REG - jsr AYINT - ldx P8ZP_SCRATCH_REG - lda floats.AYINT_facmo - sta P8ESTACK_HI,x - lda floats.AYINT_facmo+1 - sta P8ESTACK_LO,x - dex - rts - .pend - -stack_float2uw .proc ; also used for float2ub - jsr pop_float_fac1 - stx P8ZP_SCRATCH_REG - jsr GETADR - ldx P8ZP_SCRATCH_REG - sta P8ESTACK_HI,x - tya - sta P8ESTACK_LO,x - dex - rts - .pend - -push_float .proc - ; ---- push mflpt5 in A/Y onto stack - ; (taking 3 stack positions = 6 bytes of which 1 is padding) - sta P8ZP_SCRATCH_W1 - sty P8ZP_SCRATCH_W1+1 - ldy #0 - lda (P8ZP_SCRATCH_W1),y - sta P8ESTACK_LO,x - iny - lda (P8ZP_SCRATCH_W1),y - sta P8ESTACK_HI,x - dex - iny - lda (P8ZP_SCRATCH_W1),y - sta P8ESTACK_LO,x - iny - lda (P8ZP_SCRATCH_W1),y - sta P8ESTACK_HI,x - dex - iny - lda (P8ZP_SCRATCH_W1),y - sta P8ESTACK_LO,x - dex - rts - .pend - -pop_float .proc - ; ---- pops mflpt5 from stack to memory A/Y - ; (frees 3 stack positions = 6 bytes of which 1 is padding) - sta P8ZP_SCRATCH_W1 - sty P8ZP_SCRATCH_W1+1 - ldy #4 - inx - lda P8ESTACK_LO,x - sta (P8ZP_SCRATCH_W1),y - dey - inx - lda P8ESTACK_HI,x - sta (P8ZP_SCRATCH_W1),y - dey - lda P8ESTACK_LO,x - sta (P8ZP_SCRATCH_W1),y - dey - inx - lda P8ESTACK_HI,x - sta (P8ZP_SCRATCH_W1),y - dey - lda P8ESTACK_LO,x - sta (P8ZP_SCRATCH_W1),y - rts - .pend - -pop_float_fac1 .proc - ; -- pops float from stack into FAC1 - lda #fmath_float1 - jsr pop_float - lda #fmath_float1 - jmp MOVFM - .pend - -copy_float .proc - ; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_W1, - ; into the 5 bytes pointed to by A/Y. Clobbers A,Y. - sta _target+1 - sty _target+2 - ldy #4 -_loop lda (P8ZP_SCRATCH_W1),y -_target sta $ffff,y ; modified - dey - bpl _loop - rts - .pend - -inc_var_f .proc - ; -- add 1 to float pointed to by A/Y - sta P8ZP_SCRATCH_W1 - sty P8ZP_SCRATCH_W1+1 - stx P8ZP_SCRATCH_REG - jsr MOVFM - lda #FL_ONE_const - jsr FADD - ldx P8ZP_SCRATCH_W1 - ldy P8ZP_SCRATCH_W1+1 - jsr MOVMF - ldx P8ZP_SCRATCH_REG - rts - .pend - -dec_var_f .proc - ; -- subtract 1 from float pointed to by A/Y - sta P8ZP_SCRATCH_W1 - sty P8ZP_SCRATCH_W1+1 - stx P8ZP_SCRATCH_REG - lda #FL_ONE_const - jsr MOVFM - lda P8ZP_SCRATCH_W1 - ldy P8ZP_SCRATCH_W1+1 - jsr FSUB - ldx P8ZP_SCRATCH_W1 - ldy P8ZP_SCRATCH_W1+1 - jsr MOVMF - ldx P8ZP_SCRATCH_REG - rts - .pend - - -pop_2_floats_f2_in_fac1 .proc - ; -- pop 2 floats from stack, load the second one in FAC1 as well - lda #fmath_float2 - jsr pop_float - lda #fmath_float1 - jsr pop_float - lda #fmath_float2 - jmp MOVFM - .pend - - -fmath_float1 .byte 0,0,0,0,0 ; storage for a mflpt5 value -fmath_float2 .byte 0,0,0,0,0 ; storage for a mflpt5 value - - -push_fac1 .proc - ; -- push the float in FAC1 onto the stack - stx P8ZP_SCRATCH_REG -_internal ldx #fmath_float1 - jsr MOVMF - lda #fmath_float1 - ldx P8ZP_SCRATCH_REG - jmp push_float - .pend - -div_f .proc - ; -- push f1/f2 on stack - jsr pop_2_floats_f2_in_fac1 - stx P8ZP_SCRATCH_REG - lda #fmath_float1 - jsr FDIV - jmp push_fac1._internal - .pend - -add_f .proc - ; -- push f1+f2 on stack - jsr pop_2_floats_f2_in_fac1 - stx P8ZP_SCRATCH_REG - lda #fmath_float1 - jsr FADD - jmp push_fac1._internal - .pend - -sub_f .proc - ; -- push f1-f2 on stack - jsr pop_2_floats_f2_in_fac1 - stx P8ZP_SCRATCH_REG - lda #fmath_float1 - jsr FSUB - jmp push_fac1._internal - .pend - -mul_f .proc - ; -- push f1*f2 on stack - jsr pop_2_floats_f2_in_fac1 - stx P8ZP_SCRATCH_REG - lda #fmath_float1 - jsr FMULT - jmp push_fac1._internal - .pend - -neg_f .proc - ; -- toggle the sign bit on the stack - lda P8ESTACK_HI+3,x - eor #$80 - sta P8ESTACK_HI+3,x - rts - .pend - -var_fac1_less_f .proc - ; -- is the float in FAC1 < the variable AY? - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #255 - beq + - lda #0 - rts -+ lda #1 - rts - .pend - -var_fac1_lesseq_f .proc - ; -- is the float in FAC1 <= the variable AY? - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #0 - beq + - cmp #255 - beq + - lda #0 - rts -+ lda #1 - rts - .pend - -var_fac1_greater_f .proc - ; -- is the float in FAC1 > the variable AY? - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #1 - beq + - lda #0 - rts -+ lda #1 - rts - .pend - -var_fac1_greatereq_f .proc - ; -- is the float in FAC1 >= the variable AY? - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #0 - beq + - cmp #1 - beq + - lda #0 - rts -+ lda #1 - rts - .pend - -var_fac1_notequal_f .proc - ; -- are the floats numbers in FAC1 and the variable AY *not* identical? - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - and #1 - rts - .pend - -vars_equal_f .proc - ; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical? - sta P8ZP_SCRATCH_W2 - sty P8ZP_SCRATCH_W2+1 - ldy #0 - lda (P8ZP_SCRATCH_W1),y - cmp (P8ZP_SCRATCH_W2),y - bne _false - iny - lda (P8ZP_SCRATCH_W1),y - cmp (P8ZP_SCRATCH_W2),y - bne _false - iny - lda (P8ZP_SCRATCH_W1),y - cmp (P8ZP_SCRATCH_W2),y - bne _false - iny - lda (P8ZP_SCRATCH_W1),y - cmp (P8ZP_SCRATCH_W2),y - bne _false - iny - lda (P8ZP_SCRATCH_W1),y - cmp (P8ZP_SCRATCH_W2),y - bne _false - lda #1 - rts -_false lda #0 - rts - .pend - -equal_f .proc - ; -- are the two mflpt5 numbers on the stack identical? - inx - inx - inx - inx - lda P8ESTACK_LO-3,x - cmp P8ESTACK_LO,x - bne _equals_false - lda P8ESTACK_LO-2,x - cmp P8ESTACK_LO+1,x - bne _equals_false - lda P8ESTACK_LO-1,x - cmp P8ESTACK_LO+2,x - bne _equals_false - lda P8ESTACK_HI-2,x - cmp P8ESTACK_HI+1,x - bne _equals_false - lda P8ESTACK_HI-1,x - cmp P8ESTACK_HI+2,x - bne _equals_false -_equals_true lda #1 -_equals_store inx - sta P8ESTACK_LO+1,x - rts -_equals_false lda #0 - beq _equals_store - .pend - -notequal_f .proc - ; -- are the two mflpt5 numbers on the stack different? - jsr equal_f - eor #1 ; invert the result - sta P8ESTACK_LO+1,x - rts - .pend - -vars_less_f .proc - ; -- is float in AY < float in P8ZP_SCRATCH_W2 ? - jsr MOVFM - lda P8ZP_SCRATCH_W2 - ldy P8ZP_SCRATCH_W2+1 - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #255 - bne + - lda #1 - rts -+ lda #0 - rts - .pend - -vars_lesseq_f .proc - ; -- is float in AY <= float in P8ZP_SCRATCH_W2 ? - jsr MOVFM - lda P8ZP_SCRATCH_W2 - ldy P8ZP_SCRATCH_W2+1 - stx P8ZP_SCRATCH_REG - jsr FCOMP - ldx P8ZP_SCRATCH_REG - cmp #255 - bne + -- lda #1 - rts -+ cmp #0 - beq - - lda #0 - rts - .pend - -less_f .proc - ; -- is f1 < f2? - jsr compare_floats - cmp #255 - beq compare_floats._return_true - bne compare_floats._return_false - .pend - - -lesseq_f .proc - ; -- is f1 <= f2? - jsr compare_floats - cmp #255 - beq compare_floats._return_true - cmp #0 - beq compare_floats._return_true - bne compare_floats._return_false - .pend - -greater_f .proc - ; -- is f1 > f2? - jsr compare_floats - cmp #1 - beq compare_floats._return_true - bne compare_floats._return_false - .pend - -greatereq_f .proc - ; -- is f1 >= f2? - jsr compare_floats - cmp #1 - beq compare_floats._return_true - cmp #0 - beq compare_floats._return_true - bne compare_floats._return_false - .pend - -compare_floats .proc - lda #fmath_float2 - jsr pop_float - lda #fmath_float1 - jsr pop_float - lda #fmath_float1 - jsr MOVFM ; fac1 = flt1 - lda #fmath_float2 - stx P8ZP_SCRATCH_REG - jsr FCOMP ; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1 signed word in 102-103 ($66-$67) MSB FIRST. (might throw ILLEGAL QUANTITY) - -; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1 -; there is also floats.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1 -; (tip: use GIVAYFAY to use A/Y input; lo/hi switched to normal order) -romsub $af03 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y) - -romsub $af06 = FOUT() clobbers(X) -> uword @ AY ; fac1 -> string, address returned in AY -; romsub $af09 = VAL_1() clobbers(A,X,Y) ; convert ASCII string to floating point [not yet implemented!!!] - -; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15) -; (tip: use GETADRAY to get A/Y output; lo/hi switched to normal little endian order) -romsub $af0c = GETADR() clobbers(X) -> ubyte @ Y, ubyte @ A -romsub $af0f = FLOATC() clobbers(A,X,Y) ; convert address to floating point - -romsub $af12 = FSUB(uword mflpt @ AY) clobbers(A,X,Y) ; fac1 = mflpt from A/Y - fac1 -romsub $af15 = FSUBT() clobbers(A,X,Y) ; fac1 = fac2-fac1 mind the order of the operands NOTE: use FSUBT2() instead! -romsub $af18 = FADD(uword mflpt @ AY) clobbers(A,X,Y) ; fac1 += mflpt value from A/Y -romsub $af1b = FADDT() clobbers(A,X,Y) ; fac1 += fac2 NOTE: use FADDT2() instead! -romsub $af1e = FMULT(uword mflpt @ AY) clobbers(A,X,Y) ; fac1 *= mflpt value from A/Y -romsub $af21 = FMULTT() clobbers(A,X,Y) ; fac1 *= fac2 NOTE: use FMULTT2() instead! -romsub $af24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y) ; fac1 = mflpt in A/Y / fac1 -romsub $af27 = FDIVT() clobbers(A,X,Y) ; fac1 = fac2/fac1 mind the order of the operands NOTE: use FDIVT2() instead! -romsub $af2a = LOG() clobbers(A,X,Y) ; fac1 = LN(fac1) (natural log) -romsub $af2d = INT() clobbers(A,X,Y) ; INT() truncates, use FADDH first to round instead of trunc -romsub $af30 = SQR() clobbers(A,X,Y) ; fac1 = SQRT(fac1) -romsub $af33 = NEGOP() clobbers(A) ; switch the sign of fac1 (fac1 = -fac1) -romsub $af36 = FPWR(uword mflpt @ AY) clobbers(A,X,Y) ; fac1 = fac2 ** float in A/Y -romsub $af39 = FPWRT() clobbers(A,X,Y) ; fac1 = fac2 ** fac1 NOTE: use FPWRT2() instead! -romsub $af3c = EXP() clobbers(A,X,Y) ; fac1 = EXP(fac1) (e ** fac1) -romsub $af3f = COS() clobbers(A,X,Y) ; fac1 = COS(fac1) -romsub $af42 = SIN() clobbers(A,X,Y) ; fac1 = SIN(fac1) -romsub $af45 = TAN() clobbers(A,X,Y) ; fac1 = TAN(fac1) -romsub $af48 = ATN() clobbers(A,X,Y) ; fac1 = ATN(fac1) -romsub $af4b = ROUND() clobbers(A,X,Y) ; round fac1 -romsub $af4e = ABS() clobbers(A,X,Y) ; fac1 = ABS(fac1) -romsub $af51 = SIGN() clobbers(X,Y) -> ubyte @ A ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive -romsub $af54 = FCOMP(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A ; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than -romsub $af57 = RND_0() clobbers(A,X,Y) ; fac1 = RND(fac1) float random number generator -romsub $af57 = RND() clobbers(A,X,Y) ; alias for RND_0 -romsub $af5a = CONUPK(uword mflpt @ AY) clobbers(A,X,Y) ; load mflpt value from memory in A/Y into fac2 -romsub $af5d = ROMUPK(uword mflpt @ AY) clobbers(A,X,Y) ; load mflpt value from memory in current bank in A/Y into fac2 -romsub $af60 = MOVFRM(uword mflpt @ AY) clobbers(A,X,Y) ; load mflpt value from memory in A/Y into fac1 (use MOVFM instead) -romsub $af63 = MOVFM(uword mflpt @ AY) clobbers(A,X,Y) ; load mflpt value from memory in A/Y into fac1 -romsub $af66 = MOVMF(uword mflpt @ XY) clobbers(A,X,Y) ; store fac1 to memory X/Y as 5-byte mflpt -romsub $af69 = MOVFA() clobbers(A,X) ; copy fac2 to fac1 -romsub $af6c = MOVAF() clobbers(A,X) ; copy fac1 to fac2 (rounded) - -; X16 additions TODO so.... not on c128 !? -romsub $af6f = FADDH() clobbers(A,X,Y) ; fac1 += 0.5, for rounding- call this before INT -romsub $af72 = FADDT2() clobbers(A,X,Y) ; fac1 += fac2 -romsub $af75 = ZEROFC() clobbers(A,X,Y) ; fac1 = 0 -romsub $af78 = NORMAL() clobbers(A,X,Y) ; normalize fac1 (?) -romsub $af7b = NEGFAC() clobbers(A) ; switch the sign of fac1 (fac1 = -fac1) (juse use NEGOP() instead!) -romsub $af7e = FMULTT2() clobbers(A,X,Y) ; fac1 *= fac2 -romsub $af81 = MUL10() clobbers(A,X,Y) ; fac1 *= 10 -romsub $af84 = DIV10() clobbers(A,X,Y) ; fac1 /= 10 , CAUTION: result is always positive! -romsub $af87 = FDIVT2() clobbers(A,X,Y) ; fac1 = fac2/fac1 mind the order of the operands -romsub $af8a = MOVEF() clobbers(A,X) ; copy fac1 to fac2 -romsub $af8d = SGN() clobbers(A,X,Y) ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1) -romsub $af90 = FLOAT() clobbers(A,X,Y) ; FAC = (s8).A -romsub $af93 = FLOATS() clobbers(A,X,Y) ; FAC = (s16)facho+1:facho -romsub $af9C = QINT() clobbers(A,X,Y) ; facho:facho+1:facho+2:facho+3 = u32(FAC) -romsub $af9f = FINLOG(byte value @A) clobbers (A, X, Y) ; fac1 += signed byte in A -romsub $afa5 = FPWRT2() clobbers(A,X,Y) ; fac1 = fac2 ** fac1 - -asmsub FREADSA (byte value @A) clobbers(A,X,Y) { - ; ---- 8 bit signed A -> float in fac1 - %asm {{ - tay - bpl + - lda #$ff - jmp GIVAYF -+ lda #0 - jmp GIVAYF - }} -} - -asmsub GIVUAYFAY (uword value @ AY) clobbers(A,X,Y) { - ; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1 - %asm {{ - phx - sty $64 ; facmo - sta $65 ; facmo+1 - ldx #$90 - sec - jsr FLOATC - plx - rts - }} -} - -asmsub GIVAYFAY (uword value @ AY) clobbers(A,X,Y) { - ; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1 - %asm {{ - sta P8ZP_SCRATCH_B1 - tya - ldy P8ZP_SCRATCH_B1 - jmp GIVAYF ; this uses the inverse order, Y/A - }} -} - -asmsub GETADRAY () clobbers(X) -> uword @ AY { - ; ---- fac1 to unsigned word in A/Y - %asm {{ - jsr GETADR ; this uses the inverse order, Y/A - sta P8ZP_SCRATCH_B1 - tya - ldy P8ZP_SCRATCH_B1 - rts - }} -} - -asmsub FREADUY (ubyte value @Y) { - ; -- 8 bit unsigned Y -> float in fac1 - %asm {{ - lda #0 - jmp GIVAYF - }} -} - -&uword AYINT_facmo = $66 ; $66/$67 contain result of AYINT - -sub rndf() -> float { - %asm {{ - stx P8ZP_SCRATCH_REG - lda #1 - jsr RND_0 - ldx P8ZP_SCRATCH_REG - rts - }} -} - - -%asminclude "library:c128/floats.asm" -%asminclude "library:c64/floats_funcs.asm" - -}