use core::fmt;
use crate::{
Fields, Pun, Root, Variants,
layout::{self, Enum, Kind, Shape, load},
ptr,
validate::{All, check_rules, validate},
};
pub trait Visit {
type Error: From<Invalid>;
fn pointer<P: ?Sized + Pun>(&mut self, at: usize) -> Result<(), Self::Error>;
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct Invalid {
pub at: usize,
}
impl Invalid {
#[must_use]
pub const fn at(at: usize) -> Self {
Self { at }
}
}
impl fmt::Debug for Invalid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Invalid {{ at: {} }}", self.at)
}
}
impl fmt::Display for Invalid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "invalid bytes at {}", self.at)
}
}
impl core::error::Error for Invalid {}
pub type Pointee<P> = <P as Pun>::Pointee;
#[inline]
pub fn validate_in<T: Pun, V: Visit>(
bytes: &[u8],
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
let size = const { T::LAYOUT.size() };
match bytes.get(at..).and_then(|rest| rest.get(..size)) {
Some(_) => unsafe { value::<T, V>(bytes.as_ptr(), at, visit) },
None => Err(Invalid::at(at).into()),
}
}
#[inline]
pub fn validate_elems_in<T: Pun, V: Visit>(
bytes: &[u8],
at: usize,
count: usize,
visit: &mut V,
) -> Result<(), V::Error> {
let size = const { T::LAYOUT.size() };
let Some(elems) =
(size.checked_mul(count)).and_then(|len| bytes.get(at..).and_then(|rest| rest.get(..len)))
else {
return Err(Invalid::at(at).into());
};
if const { T::LAYOUT.leaves == 0 } {
return Ok(());
}
if size == 0 {
return if count == 0 { Ok(()) } else { validate_in::<T, V>(bytes, at, visit) };
}
if const { !T::LAYOUT.has_pointers() } {
let valid = unsafe { validate_elems::<T>(elems.as_ptr(), count) };
if valid {
return Ok(());
}
}
let mut i = 0;
while i < count {
unsafe { value::<T, V>(bytes.as_ptr(), at + i * size, visit)? };
i += 1;
}
if const { !T::LAYOUT.has_pointers() } {
return Err(Invalid::at(at).into());
}
Ok(())
}
#[inline]
pub unsafe fn pointers_in<T: Pun, V: Visit>(
base: *const u8,
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
unsafe { follow::<T, V>(base, at, visit) }
}
#[inline]
pub unsafe fn pointers_elems_in<T: Pun, V: Visit>(
base: *const u8,
at: usize,
count: usize,
visit: &mut V,
) -> Result<(), V::Error> {
if const { !T::LAYOUT.has_pointers() } {
return Ok(());
}
let size = const { T::LAYOUT.size() };
let mut i = 0;
while i < count {
unsafe { follow::<T, V>(base, at + i * size, visit)? };
i += 1;
}
Ok(())
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn follow<T: ?Sized + Pun, V: Visit>(
base: *const u8,
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
if const { !T::LAYOUT.has_pointers() } {
return Ok(());
}
const {
assert!(
!(matches!(T::LAYOUT.kind, Kind::Enum(layout) if layout.union) && T::LAYOUT.has_pointers()),
"a union that holds a self-relative pointer: which field it is cannot be told, so neither \
can the pointer"
);
};
const { assert!(listed::<T>(), "{}", LISTS) };
unsafe {
match const { T::LAYOUT.shape() } {
Shape::Array(len) => {
let size = const { <T::Elem as Pun>::LAYOUT.size() };
let mut i = 0;
while i < len {
follow::<T::Elem, V>(base, at + i * size, visit)?;
i += 1;
}
Ok(())
}
Shape::Struct => follow_fields::<T::Fields, V>(base, at, visit),
Shape::Enum(layout) => {
let Kind::Scalar(spec) = layout.tag.layout.kind else { return Ok(()) };
let tag = load(base.add(at + layout.tag.offset), spec.size, spec.endian);
follow_variants::<T::Variants, V>(base, at, tag, visit).unwrap_or(Ok(()))
}
Shape::Pointer(pointer) => {
if pointer.nullable && load(base.add(at), pointer.width, pointer.endian) == 0 {
Ok(())
} else {
visit.pointer::<T>(at)
}
}
Shape::Scalar(_) | Shape::Slice | Shape::Pattern(_) => Ok(()),
}
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn follow_fields<F: Fields, V: Visit>(
base: *const u8,
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
let Some(field) = (const { F::FIELD }) else { return Ok(()) };
unsafe {
if field.restriction().is_none() {
follow::<F::Type, V>(base, at + field.offset(), visit)?;
}
follow_fields::<F::Next, V>(base, at, visit)
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn follow_variants<W: Variants, V: Visit>(
base: *const u8,
at: usize,
tag: u128,
visit: &mut V,
) -> Option<Result<(), V::Error>> {
let expected = const { W::TAG }?;
let this = (const { W::RANGES }).map_or(tag == expected, |ranges| layout::contains(ranges, tag));
unsafe {
if this {
Some(follow_fields::<W::Fields, V>(base, at, visit))
} else {
follow_variants::<W::Next, V>(base, at, tag, visit)
}
}
}
#[inline]
pub unsafe fn copy_in<T: Pun>(src: *const u8, dst: *mut u8) {
unsafe { copy::<T>(src, dst) }
}
const fn whole(layout: &layout::Layout) -> bool {
match layout.kind {
Kind::Scalar(spec) => !spec.may_be_uninit(),
Kind::Array(elem, _) => whole(elem),
Kind::Struct(fields, _) => {
let (mut i, mut covered) = (0, 0);
while i < fields.len() {
if fields[i].offset != covered || !whole(fields[i].layout) {
return false;
}
covered += fields[i].layout.size;
i += 1;
}
!layout.unsized_ && covered == layout.size
}
Kind::Pointer(_) | Kind::Slice(_) | Kind::Pattern(_) | Kind::Enum(_) => false,
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn copy<T: ?Sized + Pun>(src: *const u8, dst: *mut u8) {
let size = const { T::LAYOUT.size() };
if const { whole(&T::LAYOUT) } {
unsafe { core::ptr::copy_nonoverlapping(src, dst, size) };
return;
}
const {
assert!(
!matches!(T::LAYOUT.kind, Kind::Enum(layout) if layout.union),
"`copy_in` of a union: which of its fields it is, and so which of its bytes are \
initialized, cannot be told"
);
};
const { assert!(listed::<T>(), "{}", LISTS) };
unsafe {
match const { T::LAYOUT.shape() } {
Shape::Array(len) => {
let size = const { <T::Elem as Pun>::LAYOUT.size() };
let mut i = 0;
while i < len {
copy::<T::Elem>(src.add(i * size), dst.add(i * size));
i += 1;
}
}
Shape::Struct => copy_fields::<T::Fields>(src, dst),
Shape::Enum(layout) => {
let Kind::Scalar(spec) = layout.tag.layout.kind else { return };
let place = layout.tag.offset;
let tag = load(src.add(place), spec.size, spec.endian);
core::ptr::copy_nonoverlapping(src.add(place), dst.add(place), spec.size);
copy_variants::<T::Variants>(src, dst, tag);
}
Shape::Pointer(pointer) => {
if pointer.nullable && load(src, pointer.width, pointer.endian) == 0 {
core::ptr::copy_nonoverlapping(src, dst, size);
}
}
Shape::Scalar(_) | Shape::Slice | Shape::Pattern(_) => {}
}
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn copy_fields<F: Fields>(src: *const u8, dst: *mut u8) {
let Some(field) = (const { F::FIELD }) else { return };
let off = field.offset();
unsafe {
copy::<F::Type>(src.add(off), dst.add(off));
copy_fields::<F::Next>(src, dst);
}
}
#[cfg_attr(not(debug_assertions), inline(always))]
unsafe fn copy_variants<W: Variants>(src: *const u8, dst: *mut u8, tag: u128) {
let Some(expected) = (const { W::TAG }) else { return };
let this = (const { W::RANGES }).map_or(tag == expected, |ranges| layout::contains(ranges, tag));
unsafe {
if this {
copy_fields::<W::Fields>(src, dst);
} else {
copy_variants::<W::Next>(src, dst, tag);
}
}
}
#[inline(always)]
const unsafe fn validate_elems<T: Pun>(base: *const u8, count: usize) -> bool {
unsafe { validate::<All, Root, [T]>(ptr::from_raw_parts::<[T]>(base, count)) }
}
#[inline(always)]
unsafe fn value<T: ?Sized + Pun, V: Visit>(
base: *const u8,
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
if const { T::LAYOUT.leaves == 0 } {
return Ok(());
}
const {
assert!(
!(matches!(T::LAYOUT.kind, Kind::Enum(layout) if layout.union) && T::LAYOUT.has_pointers()),
"a union that holds a self-relative pointer: which field it is cannot be told, so neither \
can the pointer"
);
};
const { assert!(listed::<T>(), "{}", LISTS) };
let here = unsafe { base.add(at) };
if const { !T::LAYOUT.has_pointers() } {
if unsafe { validate::<All, Root, T>(ptr::from_raw_parts::<T>(here, 0)) } {
return Ok(());
}
return match unsafe { walk::<T, V>(base, at, here, visit) } {
Ok(()) => Err(Invalid::at(at).into()),
error => error,
};
}
unsafe { walk::<T, V>(base, at, here, visit) }
}
#[inline(always)]
unsafe fn walk<T: ?Sized + Pun, V: Visit>(
base: *const u8,
at: usize,
here: *const u8,
visit: &mut V,
) -> Result<(), V::Error> {
unsafe {
match const { T::LAYOUT.shape() } {
Shape::Scalar(spec) => {
if spec.matches(here) {
Ok(())
} else {
Err(Invalid::at(at).into())
}
}
Shape::Array(len) => {
let size = const { <T::Elem as Pun>::LAYOUT.size() };
let mut i = 0;
while i < len {
value::<T::Elem, V>(base, at + i * size, visit)?;
i += 1;
}
Ok(())
}
Shape::Struct => {
fields::<T::Fields, V>(base, at, visit)?;
if const { T::LAYOUT.rules().is_empty() } || check_rules::<T>(ptr::from_raw_parts(here, 0))
{
Ok(())
} else {
Err(Invalid::at(at).into())
}
}
Shape::Enum(layout) if layout.union => Err(Invalid::at(at).into()),
Shape::Enum(layout) => enumeration::<T, V>(base, at, layout, visit),
Shape::Pointer(pointer) => match load(here, pointer.width, pointer.endian) {
0 if pointer.nullable => Ok(()),
0 if pointer.nonzero => Err(Invalid::at(at).into()),
_ => visit.pointer::<T>(at),
},
Shape::Slice | Shape::Pattern(_) => Err(Invalid::at(at).into()),
}
}
}
const LISTS: &str = "an implementation of `Pun` lists fields, variants or elements that are not \
those of its layout: `validate_in` goes by the lists, and would not check \
what they leave out";
const fn listed<T: ?Sized + Pun>() -> bool {
match T::LAYOUT.kind {
Kind::Struct(fields, _) => fields_listed::<T::Fields>(fields, 0),
Kind::Enum(layout) => variants_listed::<T::Variants>(layout.variants, 0),
Kind::Array(elem, _) | Kind::Slice(elem) => <T::Elem as Pun>::LAYOUT.equals(elem),
Kind::Pointer(pointer) => {
let target = <T::Pointee as Pun>::LAYOUT;
target.size() == pointer.size && target.align() == pointer.align
}
Kind::Scalar(_) | Kind::Pattern(_) => true,
}
}
const fn fields_listed<F: Fields>(fields: &[layout::Field], index: usize) -> bool {
let Some(field) = F::FIELD else { return index == fields.len() };
let mut i = 0;
let mut found = false;
while i < fields.len() {
let other = &fields[i];
found |= other.index == index
&& other.offset == field.offset
&& other.restricted == field.restricted
&& other.layout.equals(field.layout);
i += 1;
}
found
&& field.index == index
&& (field.restricted || <F::Type as Pun>::LAYOUT.equals(field.layout))
&& fields_listed::<F::Next>(fields, index + 1)
}
const fn variants_listed<W: Variants>(variants: &[layout::Variant], index: usize) -> bool {
let Some(tag) = W::TAG else { return index == variants.len() };
index < variants.len()
&& variants[index].tag == tag
&& same_ranges(W::RANGES, variants[index].ranges)
&& fields_listed::<W::Fields>(variants[index].fields(), 0)
&& variants_listed::<W::Next>(variants, index + 1)
}
const fn same_ranges(a: Option<&[(u128, u128)]>, b: Option<&[(u128, u128)]>) -> bool {
match (a, b) {
(None, None) => true,
(Some(a), Some(b)) => {
if a.len() != b.len() {
return false;
}
let mut i = 0;
while i < a.len() {
if a[i].0 != b[i].0 || a[i].1 != b[i].1 {
return false;
}
i += 1;
}
true
}
_ => false,
}
}
#[inline(always)]
unsafe fn fields<F: Fields, V: Visit>(
base: *const u8,
at: usize,
visit: &mut V,
) -> Result<(), V::Error> {
let Some(field) = (const { F::FIELD }) else { return Ok(()) };
let place = at + field.offset();
unsafe {
match field.restriction() {
Some(spec) => {
if !spec.matches(base.add(place)) {
return Err(Invalid::at(place).into());
}
}
None => value::<F::Type, V>(base, place, visit)?,
}
fields::<F::Next, V>(base, at, visit)
}
}
#[inline(always)]
unsafe fn enumeration<T: ?Sized + Pun, V: Visit>(
base: *const u8,
at: usize,
layout: &Enum,
visit: &mut V,
) -> Result<(), V::Error> {
let Kind::Scalar(spec) = layout.tag.layout.kind else { return Err(Invalid::at(at).into()) };
let place = at + layout.tag.offset;
let tag = unsafe { load(base.add(place), spec.size, spec.endian) };
unsafe { variants::<T::Variants, V>(base, at, tag, visit) }
.unwrap_or_else(|| Err(Invalid::at(place).into()))
}
#[inline(always)]
unsafe fn variants<W: Variants, V: Visit>(
base: *const u8,
at: usize,
tag: u128,
visit: &mut V,
) -> Option<Result<(), V::Error>> {
let expected = const { W::TAG }?;
let this = (const { W::RANGES }).map_or(tag == expected, |ranges| layout::contains(ranges, tag));
unsafe {
if this {
Some(fields::<W::Fields, V>(base, at, visit))
} else {
variants::<W::Next, V>(base, at, tag, visit)
}
}
}