Compiler Explorer

Source code

pub fn print(n: i32) -> Option<String> {
    unsafe fn print_line(v: &mut String, width: usize, max_width: usize) {
        for _ in 0..(max_width - width) / 2 {
            v.push_unchecked(' ');
        }
        for _ in 0..width {
            v.push_unchecked('*');
        }
        v.push_unchecked('\n');
    }

if n < 0 || n % 2 == 0 {
        return None;
    }
    let n = n as usize;

let cap = n.pow(2) + 1;
    let mut res = String::with_capacity(cap);

let mut width = 1;
    while width <= n {
        unsafe { print_line(&mut res, width, n) };
        width += 2;
    }

width = n;
    while width > 1 {
        width -= 2;
        unsafe { print_line(&mut res, width, n) };
    }

Some(res)
}

pub fn push(s: &mut String, ch: char) {
    if s.capacity() - s.len() < ch.len_utf8() {
        s.reserve(ch.len_utf8());
    }
    unsafe { s.push_unchecked(ch) };
}

const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;

#[inline]
const fn len_utf8(code: u32) -> usize {
    if code < MAX_ONE_B {
        1
    } else if code < MAX_TWO_B {
        2
    } else if code < MAX_THREE_B {
        3
    } else {
        4
    }
}

#[inline]
unsafe fn encode_utf8_raw_unchecked(code: u32, dst: &mut [u8]) -> &mut [u8] {
    let len = len_utf8(code);
    match len {
        1 => {
            *dst.get_unchecked_mut(0) = code as u8;
        }
        2 => {
            *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
            *dst.get_unchecked_mut(1) = (code & 0x3F) as u8 | TAG_CONT;
        }
        3 => {
            *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
            *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
            *dst.get_unchecked_mut(2) = (code & 0x3F) as u8 | TAG_CONT;
        }
        4 => {
            *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
            *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
            *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
            *dst.get_unchecked_mut(3) = (code & 0x3F) as u8 | TAG_CONT;
        }
        _ => core::hint::unreachable_unchecked(),
    };
    dst.get_unchecked_mut(..len)
}

pub trait PushUnchecked<T> {
    unsafe fn push_unchecked(&mut self, value: T);
}

impl PushUnchecked<char> for String {
    #[inline]
    unsafe fn push_unchecked(&mut self, ch: char) {
        let len = self.len();
        let count = ch.len_utf8();
        let spare = core::slice::from_raw_parts_mut(
            self.as_mut_vec().as_mut_ptr().add(len),
            self.capacity() - len,
        );
        encode_utf8_raw_unchecked(ch as u32, spare);
        self.as_mut_vec().set_len(len + count);
    }
}

#[inline]
pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> &mut [u8] {
    let len = len_utf8(code);
    if dst.len() < len {
        panic!(
            "encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}",
            len,
            code,
            dst.len(),
        );
    }
    unsafe { encode_utf8_raw_unchecked(code, dst) }
}

#[inline]
unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str {
    unsafe { &mut *(v as *mut [u8] as *mut str) }
}

pub fn encode_utf8(c: char, dst: &mut [u8]) -> &mut str {
    unsafe { from_utf8_unchecked_mut(encode_utf8_raw(c as u32, dst)) }
}