Function format_float

compiler/src/modules/vm/handlers/format.rs:200–245

(v: Val, s: &Spec, ty: u8, heap: &HeapPool)

}

fn format_float(v: Val, s: &Spec, ty: u8, heap: &HeapPool) -> Result<String, &'static str> {
    let f = require_float(v, heap)?;
    let prec = s.precision.unwrap_or(6);

    /* NaN/inf go through unchanged (emits "nan"/"inf" before padding). */
    if f.is_nan() {
        let body = if ty == b'F' { "NAN" } else { "nan" };
        return Ok(pad_string(s, body));
    }
    if f.is_infinite() {
        let mut out = String::new();
        let sign_ch = sign_char(f.is_sign_negative(), s.sign);
        if let Some(c) = sign_ch { out.push(c); }
        out.push_str(if ty == b'F' { "INF" } else { "inf" });
        return Ok(pad_aligned(s, &out, sign_ch.map(|_| 1).unwrap_or(0)));
    }

    let mag = f.abs();
    let body = match ty {
        b'f' | b'F' => fixed(mag, prec),
        // e/g delegate to Rust's f64 formatter; round-half-to-even applies only to `f`.
        b'e' => format_with_e(mag, prec, false),
        b'E' => format_with_e(mag, prec, true),
        // `g/G`: pick `e` for very small/large, `f` otherwise.
        b'g' | b'G' => {
            let upper = ty == b'G';
            let exp = if mag == 0.0 { 0 } else { ffloor(flog10(mag)) as i32 };
            // rule: -4 <= exp < precision uses fixed; else scientific.
            let p = prec.max(1);
            if exp < -4 || exp >= p as i32 {
                format_with_e(mag, p.saturating_sub(1), upper)
            } else {
                let dec = (p as i32 - 1 - exp).max(0) as usize;
                let out = fixed(mag, dec);
                if upper { out.to_uppercase() } else { out }
            }
        }
        _ => unreachable!(),
    };
    let body = if s.sep != 0 { add_thousands_float(&body, s.sep) } else { body };
    let sign_ch = sign_char(f.is_sign_negative(), s.sign);
    let mut left = String::new();
    if let Some(c) = sign_ch { left.push(c); }
    left.push_str(&body);
    Ok(pad_aligned(s, &left, sign_ch.map(|_| 1).unwrap_or(0)))
}

fn format_with_e(mag: f64, prec: usize, upper: bool) -> String {
    // Rust emits "3.14e0"; expects "e+00", inject the sign and pad exponent to >=2 digits.