Compiler Explorer

Source code

const fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {
    (ch << 6) | (byte & CONT_MASK) as u32
}

const fn utf8_first_byte(byte: u8, width: u32) -> u32 {
    (byte & (0x7F >> width)) as u32
}

const CONT_MASK: u8 = 0b0011_1111;

pub const fn utf8_is_cont_byte(byte: u8) -> bool {
    (byte as i8) < -64
}

pub unsafe fn src<'a, I>(bytes: &mut I) -> Option<u32>
where
    I: DoubleEndedIterator<Item = &'a u8>,
{
    // Decode UTF-8
    let w = match *bytes.next_back()? {
        next_byte if next_byte < 128 => return Some(next_byte as u32),
        back_byte => back_byte,
    };

// Multibyte case follows
    // Decode from a byte combination out of: [x [y [z w]]]
    let mut ch;
    // SAFETY: `bytes` produces an UTF-8-like string,
    // so the iterator must produce a value here.
    let z = unsafe { *bytes.next_back().unwrap_unchecked() };
    ch = utf8_first_byte(z, 2);
    if utf8_is_cont_byte(z) {
        // SAFETY: `bytes` produces an UTF-8-like string,
        // so the iterator must produce a value here.
        let y = unsafe { *bytes.next_back().unwrap_unchecked() };
        ch = utf8_first_byte(y, 3);
        if utf8_is_cont_byte(y) {
            // SAFETY: `bytes` produces an UTF-8-like string,
            // so the iterator must produce a value here.
            let x = unsafe { *bytes.next_back().unwrap_unchecked() };
            ch = utf8_first_byte(x, 4);
            ch = utf8_acc_cont_byte(ch, y);
        }
        ch = utf8_acc_cont_byte(ch, z);
    }
    ch = utf8_acc_cont_byte(ch, w);

Some(ch)
}

pub unsafe fn tgt<'a, I>(bytes: &mut I) -> Option<u32>
where
    I: DoubleEndedIterator<Item = &'a u8>,
{
    let b1 = *bytes.next_back()?;
    if b1 < 0x80 {
        // 1 byte (ASCII) case:
        // c = b1
        return Some(b1 as u32);
    }

// SAFETY: `bytes` produces a UTF-8-like string
    let b2 = unsafe { *bytes.next_back().unwrap_unchecked() };
    let c = u32::from(b1 & 0x3F) | u32::from(b2 & 0x3F) << 6;
    if !utf8_is_cont_byte(b2) {
        // 2 byte case:
        // c = (b2 & 0x3F) << 6
        //   | (b1 & 0x3F) << 0
        return Some(c);
    }

// SAFETY: `bytes` produces a UTF-8-like string
    let b3 = unsafe { *bytes.next_back().unwrap_unchecked() };
    let c = c | u32::from(b3 & 0x3F) << 12;
    if !utf8_is_cont_byte(b3) {
        // 3 byte case:
        // c = ((b3 & 0x3F) << 12
        //    | (b2 & 0x3F) << 6
        //    | (b1 & 0x3F) << 0) & 0xFF_FF
        return Some(c & 0xFF_FF);
    }

// SAFETY: `bytes` produces a UTF-8-like string
    let b4 = unsafe { *bytes.next_back().unwrap_unchecked() };
    let c = c | u32::from(b4 & 0x07) << 18;
    // 4 byte case:
    // c = (b4 & 0x07) << 18
    //   | (b3 & 0x3F) << 12
    //   | (b2 & 0x3F) << 6
    //   | (b1 & 0x3F) << 0
    Some(c)
}

pub fn src1(s: &str) -> Option<char> {
    unsafe {
        let codepoint = src(&mut s.as_bytes().iter())?;
        Some(char::from_u32_unchecked(codepoint))
    }
}

pub fn tgt1(s: &str) -> Option<char> {
    unsafe {
        let codepoint = tgt(&mut s.as_bytes().iter())?;
        Some(char::from_u32_unchecked(codepoint))
    }
}