Compiler Explorer

Source code

#![feature(ascii_char)]
#![feature(maybe_uninit_slice)]

use core::fmt;
use core::slice;
use core::str;
use core::mem::MaybeUninit;

pub fn foo(n: u128, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    // Check arguments at compile time.
    assert!(u128::MIN == 0);
    b"01234567".as_ascii().unwrap();

// ASCII digits in ascending order are used as a lookup table.
    const DIG_TAB: &[u8] = b"01234567";
    const BASE: u128 = DIG_TAB.len() as u128;
    const MAX_DIG_N: usize = u128::MAX.ilog(BASE) as usize + 1;

// Buffer digits of self with right alignment.
    let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DIG_N];
    // Count the number of bytes in buf that are not initialized.
    let mut offset = buf.len();

// Accumulate each digit of the number from the least
    // significant to the most significant figure.
    let mut remain = n;
    loop {
        let digit = remain % BASE;
        remain /= BASE;
        // SAFETY: All of the decimals fit in buf due to MAX_DEC_N
        // and the break condition below ensures at least 1 more
        // decimal.
        unsafe { core::hint::assert_unchecked(offset >= 1) }
        // SAFETY: The offset counts down from its initial buf.len()
        // without underflow due to the previous precondition.
        unsafe { core::hint::assert_unchecked(offset <= buf.len()) }
        offset -= 1;
        buf[offset].write(DIG_TAB[digit as usize]);
        if remain == 0 {
            break;
        }
    }

// SAFETY: All buf content since offset is set.
    let written = unsafe { buf.get_unchecked(offset..) };
    // SAFETY: Writes are ASCII numbers exclusively.
    let as_str = unsafe {
        str::from_utf8_unchecked(slice::from_raw_parts(
            MaybeUninit::slice_as_ptr(written),
            written.len(),
        ))
    };
    f.pad_integral(true, "0o", as_str)
}