use core::hint::unreachable_unchecked;
type Utf8ErrorCompat = crate::compat::Utf8Error;
#[inline]
#[allow(clippy::cast_possible_truncation)]
pub(crate) unsafe fn validate_utf8_at_offset(
input: &[u8],
offset: usize,
) -> Result<(), Utf8ErrorCompat> {
let input = input.get_unchecked(offset..);
match core::str::from_utf8(input) {
Ok(_) => Ok(()),
Err(err) => Err(Utf8ErrorCompat {
valid_up_to: err.valid_up_to() + offset,
error_len: err.error_len().map(|len| {
len as u8
}),
}),
}
}
#[inline]
unsafe fn unwrap_err_unchecked<O, E>(r: Result<O, E>) -> E {
match r {
Ok(_) => unreachable_unchecked(),
Err(e) => e,
}
}
#[cold]
#[allow(dead_code)] pub(crate) fn get_compat_error(input: &[u8], failing_block_pos: usize) -> Utf8ErrorCompat {
let offset = if failing_block_pos == 0 {
0
} else {
let mut found = failing_block_pos;
let mut i = 1;
while i <= 3 {
if *(unsafe { input.get_unchecked(failing_block_pos - i) }) >> 6 != 0b10 {
found = failing_block_pos - i;
break;
}
i += 1;
}
found
};
unsafe { unwrap_err_unchecked(validate_utf8_at_offset(input, offset)) }
}
#[allow(dead_code)] #[inline(always)] pub(crate) unsafe fn memcpy_unaligned_nonoverlapping_inline_opt_lt_64(
src: *const u8,
dest: *mut u8,
mut len: usize,
) {
#[inline(always)]
#[allow(clippy::inline_always)]
unsafe fn copy_u64_at(src: *const u8, dest: *mut u8, off: usize) {
dest.add(off)
.cast::<u64>()
.write_unaligned(src.add(off).cast::<u64>().read_unaligned());
}
let mut off = 0usize;
if len >= 32 {
copy_u64_at(src, dest, off);
copy_u64_at(src, dest, off + 8);
copy_u64_at(src, dest, off + 16);
copy_u64_at(src, dest, off + 24);
off += 32;
len -= 32;
}
if len >= 16 {
copy_u64_at(src, dest, off);
copy_u64_at(src, dest, off + 8);
off += 16;
len -= 16;
}
if len >= 8 {
copy_u64_at(src, dest, off);
off += 8;
len -= 8;
}
if len >= 4 {
dest.add(off)
.cast::<u32>()
.write_unaligned(src.add(off).cast::<u32>().read_unaligned());
off += 4;
len -= 4;
}
if len >= 2 {
dest.add(off)
.cast::<u16>()
.write_unaligned(src.add(off).cast::<u16>().read_unaligned());
off += 2;
len -= 2;
}
if len == 1 {
*dest.add(off) = *src.add(off);
}
}
pub(crate) const SIMD_CHUNK_SIZE: usize = 64;
#[repr(C, align(32))]
#[allow(dead_code)] pub(crate) struct Utf8CheckAlgorithm<T> {
pub(crate) prev: T,
pub(crate) incomplete: T,
pub(crate) error: T,
}
#[repr(C, align(16))]
#[allow(dead_code)] pub(crate) struct TempSimdChunkA16(pub(crate) [u8; SIMD_CHUNK_SIZE]);
#[allow(dead_code)] impl TempSimdChunkA16 {
#[allow(clippy::inline_always)]
#[inline(always)] pub(crate) const fn new() -> Self {
Self([0; SIMD_CHUNK_SIZE])
}
}
#[repr(C, align(32))]
#[allow(dead_code)] pub(crate) struct TempSimdChunkA32(pub(crate) [u8; SIMD_CHUNK_SIZE]);
#[repr(C, align(64))]
#[allow(dead_code)] pub(crate) struct TempSimdChunkA64(pub(crate) [u8; SIMD_CHUNK_SIZE]);
#[allow(dead_code)] impl TempSimdChunkA32 {
#[allow(clippy::inline_always)]
#[inline(always)] pub(crate) const fn new() -> Self {
Self([0; SIMD_CHUNK_SIZE])
}
}
#[allow(dead_code)] impl TempSimdChunkA64 {
#[allow(clippy::inline_always)]
#[inline(always)] pub(crate) const fn new() -> Self {
Self([0; SIMD_CHUNK_SIZE])
}
}
#[derive(Clone, Copy)]
#[allow(dead_code)] pub(crate) struct SimdU8Value<T>(pub(crate) T)
where
T: Copy;