c64 0.1.0-alpha.1

//! BASIC ROM constants and functions.

use core::cmp::Ordering;

use crate::pac::kernal::{AllTerms, OddTerms, Polynomial, F40};

extern "C" {
    fn basic_facinx() -> i16;
    fn basic_givayf(value: i16);
    fn basic_fsub(addr: *const u8);
    fn basic_fsubt();
    fn basic_fadd(addr: *const u8);
    fn basic_faddt();
    fn basic_log();
    fn basic_fmult(addr: *const u8);
    fn basic_mul10();
    fn basic_div10();
    fn basic_fdivarg(addr: *const u8);
    fn basic_fdiv(addr: *const u8);
    fn basic_fdivt();
    fn basic_movfm(addr: *const u8);
    fn basic_movmf(addr: *mut u8);
    fn basic_movaf() -> u8;
    fn basic_movfa() -> u8;
    fn basic_round();
    fn basic_sign() -> i8;
    fn basic_sgn();
    fn basic_abs();
    fn basic_fcomp(addr: *const u8) -> i8;
    fn basic_qint();
    fn basic_int();
    fn basic_fout() -> *const i8;
    fn basic_sqr();
    fn basic_fpwr(addr: *const u8);
    fn basic_fpwrt();
    fn basic_negop();
    fn basic_exp();
}

/// Pointer to the BASIC ROM identifier "CBMBASIC".
pub const IDENTIFIER: *const [u8; 8] = 0xa004 as *const _;

/// Pointer to the logarithm constants in the BASIC ROM.
pub const LOG_CONSTANTS: *const LogConstants = 0xb9bc as *const _;

/// The logarithm constants in the BASIC ROM.
#[repr(C, packed)]
pub struct LogConstants {
    /// The encoding of 1.0.
    pub one: F40,
    /// The polynomial table approximating `log_2(√2/(1 - X) - √0.5)` over the domain `[-(3-2√2), (3-2√2))`.
    pub logcn2: Polynomial<OddTerms, 4>,
    /// The approximation of (√2)/2.
    pub root_2_over_2: F40,
    /// The approximation of √2.
    pub root_2: F40,
    /// The encoding of -0.5.
    pub neg_0_point_5: F40,
}

/// Pointer to the inverse natural log (e^x) constants in the BASIC ROM.
pub const EXP_CONSTANTS: *const ExpConstants = 0xbfbf as *const _;

/// The inverse natural log (e^x) constants in the BASIC ROM.
#[repr(C, packed)]
pub struct ExpConstants {
    /// The approximation of `1/ln(2)`.
    pub one_over_ln_2: F40,
    /// The polynomial table approximating `2^X` over the domain `[0, 1)`.
    pub two_pow_x: Polynomial<AllTerms, 8>,
}

/// Convert number in FAC into a 16-bit signed integer.
///
/// Triggers an `?ILLEGAL QUANTITY ERROR` if the number in FAC is not in range for `i16`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn facinx() -> i16 {
    unsafe { basic_facinx() }
}

/// Convert 16-bit signed integer into a floating point number in FAC.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn givayf(value: i16) {
    unsafe { basic_givayf(value) }
}

/// Sets `ARG = value`, then `FAC = value - FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fsub(value: *const F40) {
    unsafe { basic_fsub(value as _) }
}

/// Sets `FAC = ARG - FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fsubt() {
    unsafe { basic_fsubt() }
}

/// Sets `ARG = value`, then `FAC = FAC + value`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fadd(value: *const F40) {
    unsafe { basic_fadd(value as _) }
}

/// Sets `FAC = ARG + FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn faddt() {
    unsafe { basic_faddt() }
}

/// Sets `FAC = ln(FAC)`.
///
/// After this call, the contents of ARG is undefined.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn log() {
    unsafe { basic_log() }
}

/// Sets `FAC = FAC * value`.
///
/// After this call, the contents of ARG is undefined.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fmult(value: *const F40) {
    unsafe { basic_fmult(value as _) }
}

/// Sets `ARG = FAC`, then `FAC = FAC * 10`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn mul10() {
    unsafe { basic_mul10() }
}

/// Sets `ARG = FAC`, then `FAC = |FAC| / 10`.
///
/// Ignores the sign of the number in FAC; the result is always positive.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn div10() {
    unsafe { basic_div10() }
}

/// Sets `FAC = ARG / value`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fdivarg(value: *const F40) {
    unsafe { basic_fdivarg(value as _) }
}

/// Sets `ARG = value`, then `FAC = value / FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fdiv(value: *const F40) {
    unsafe { basic_fdiv(value as _) }
}

/// Sets `FAC = ARG / FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fdivt() {
    unsafe { basic_fdivt() }
}

/// Load FAC from memory.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn movfm(value: *const F40) {
    unsafe { basic_movfm(value as _) }
}

/// Store FAC to memory.
///
/// Triggers an `?OVERFLOW ERROR` if, after rounding, the contents of FAC can no longer be
/// represented as a floating point number on the C64.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn movmf(value: *mut F40) {
    unsafe { basic_movmf(value as _) }
}

/// Copy a number currently in ARG, over into FAC.
///
/// Returns the exponent of the number.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn movaf() -> u8 {
    unsafe { basic_movaf() }
}

/// Copy a number currently in FAC, over into ARG.
///
/// Returns the exponent of the number.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn movfa() -> u8 {
    unsafe { basic_movfa() }
}

/// Rounds FAC to an encodable floating point number.
///
/// This is used internally by [`movmf`] and [`movfa`].
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn round() {
    unsafe { basic_round() }
}

/// Compares FAC to zero.
///
/// This is a faster way to obtain the sign of FAC than [`fcomp`].
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn sign() -> Ordering {
    match unsafe { basic_sign() } {
        0 => Ordering::Equal,
        1 => Ordering::Greater,
        -1 => Ordering::Less,
        _ => unreachable!(),
    }
}

/// Sets the mantissa of FAC to 1 if it is non-zero.
///
/// This has the effect of setting FAC to 1 if it is positive, and -1 if it is negative.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn sgn() {
    unsafe { basic_sgn() }
}

/// Sets `FAC = |FAC|`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn abs() {
    unsafe { basic_abs() }
}

/// Compares FAC to the given number.
///
/// Also sets processor flags (N,Z) depending on whether the number in FAC is zero,
/// positive, or negative.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fcomp(value: *const F40) -> Ordering {
    let ret = unsafe { basic_fcomp(value as _) };
    match ret {
        1 => Ordering::Greater,
        0 => Ordering::Equal,
        -1 => Ordering::Less,
        _ => unreachable!(),
    }
}

/// Converts FAC into an `i32` internally, truncating all decimal places.
///
/// A negative number is encoded in the FAC's mantissa slot as two's complement, instead
/// of using the normal separate sign bit.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn qint() {
    unsafe { basic_qint() }
}

/// Rounds FAC towards negative infinity to an integer.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn int() {
    unsafe { basic_int() }
}

/// Converts the contents of FAC into a nul-terminated ASCII string.
///
/// After this call, the contents of FAC is undefined.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fout() -> *const i8 {
    unsafe { basic_fout() }
}

/// Sets `ARG = FAC`, then `FAC = FAC^0.5`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn sqr() {
    unsafe { basic_sqr() }
}

/// Sets `FAC = ARG^value`.
///
/// After this call, the contents of ARG is undefined: the routine internally calls
/// `FMUL` (which clobbers ARG via `CONUPK`) and then `EXP` (which clobbers ARG via
/// its polynomial evaluation).
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fpwr(value: *const F40) {
    unsafe { basic_fpwr(value as _) }
}

/// Sets `FAC = ARG^FAC`.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn fpwrt() {
    unsafe { basic_fpwrt() }
}

/// Switches sign on the number in FAC, if non-zero.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn negop() {
    unsafe { basic_negop() }
}

/// Sets `FAC = e^FAC`.
///
/// After this call, the contents of ARG is undefined.
///
/// # Safety
///
/// - Do not call this function if the BASIC ROM overlay is disabled.
#[inline]
pub unsafe fn exp() {
    unsafe { basic_exp() }
}