Function unicode_char

alpm-mtree/src/path_decoder.rs:91–142

Parse and decode a unicode char that's encoded as octal triplets. For example, 🌠 translates to `\360\237\214\240`, which is equivalent to `0xf0 0x9f 0x8c 0xa0` hex encoding. Each triplet represents a single UTF-8 byte segment, check [`octal_triplet`] for more details.

(input: &mut &str)

///
/// Each triplet represents a single UTF-8 byte segment, check [`octal_triplet`] for more details.
fn unicode_char(input: &mut &str) -> ModalResult<String> {
    // A unicode char can consist of up to 4 bytes, which is what we use this buffer for.
    let mut unicode_bytes = Vec::new();

    // Create a checkpoint in case there's an error while decoding the whole
    // byte sequence in the very end.
    let checkpoint = input.checkpoint();

    // Parse the first octal triplet into bytes.
    // If the input isn't an octal triplet, we hit an unknown encoding and return a backtrack error
    // for a better error message on a higher level.
    let first = octal_triplet(input)?;

    unicode_bytes.push(first);

    // Get the number of leading ones, which determines the amount of following
    // bytes in this unicode char. This amount of leading ones can be one of `[0, 2, 3, 4]`.
    // Other values are forbidden.
    let leading_ones: usize = first.leading_ones() as usize;

    // If there're no leading ones this char is a single byte UTF-8 char.
    if leading_ones == 0 {
        return bytes_to_string(input, checkpoint, unicode_bytes);
    }

    // Make sure that we didn't get an invalid amount of leading zeroes
    if leading_ones > 4 || leading_ones == 1 {
        let mut error = ContextError::new();
        error = error.add_context(
            input,
            &checkpoint,
            StrContext::Label("amount of leading zeroes in first UTF-8 byte"),
        );
        return Err(ErrMode::Cut(error));
    }

    // Due to the amount of leading ones, we know how many bytes we have to expect.
    // Parse the amount of expected bytes and throw an error if that didn't work out.
    for _ in 1..leading_ones {
        let byte = cut_err(octal_triplet)
            .context(StrContext::Label("utf8 encoded byte"))
            .context(StrContext::Expected(StrContextValue::Description(
                "octal triplet encoded unicode byte.",
            )))
            .parse_next(input)?;

        unicode_bytes.push(byte);
    }

    // Read the bytes to string, which might result in another parser error.
    bytes_to_string(input, checkpoint, unicode_bytes)
}

/// Take the UTF-8 byte sequence and parse it into a `String`.
///