use bstack::{BStack, BStackRange};
use crate::BStackRaiiAllocator;
use crate::io_core::refcount;
use crate::primitives::{EightCC, NonNullOffset, Offset};
use crate::types::compiled::rc::{
CTRL_BACKPTR_OFFSET, CTRL_STRONG_OFFSET, CTRL_WEAK_OFFSET, RC_REFCOUNT_OFFSET,
};
use crate::util::read_u64;
use super::{AnyRef, BYTEVEC_HEADER, CONTROL_SIZE, RttiEnum, RttiVariant, Value, add_off};
use super::{RttiResult, rtti_err};
pub(in crate::rtti) fn verify_data_block(
data: &BStack,
off: Offset,
tag: EightCC,
) -> RttiResult<()> {
let Some(off) = off.to_non_null() else {
return Ok(());
};
let bad_target = |found: Option<EightCC>| {
let found = match found {
Some(t) => format!("found {t:?}"),
None => "out of bounds or unreadable".to_string(),
};
rtti_err!(
Mutator,
"RTTI mutator: offset {} does not hold a live {:?} block ({})",
off.as_u64(),
tag,
found
)
};
match AnyRef::from_block(data, off.as_u64()) {
Ok(a) if a.tag() == tag => Ok(()),
Ok(a) => Err(bad_target(Some(a.tag()))),
Err(_) => Err(bad_target(None)),
}
}
thread_local! {
static RTTI_DEPTH: core::cell::Cell<u32> = const { core::cell::Cell::new(0) };
}
const MAX_RTTI_DEPTH: u32 = 100;
pub(in crate::rtti) struct DepthGuard;
impl DepthGuard {
pub(in crate::rtti) fn enter() -> RttiResult<Self> {
let depth = RTTI_DEPTH.with(|c| {
let n = c.get() + 1;
c.set(n);
n
});
if depth > MAX_RTTI_DEPTH {
RTTI_DEPTH.with(|c| c.set(c.get() - 1)); return Err(rtti_err!(
Budget,
"RTTI cross-file recursion too deep (a foreign cycle?)",
));
}
Ok(DepthGuard)
}
}
impl Drop for DepthGuard {
fn drop(&mut self) {
RTTI_DEPTH.with(|c| c.set(c.get().saturating_sub(1)));
}
}
pub(in crate::rtti) fn checked_vec_len(
byte_len: u64,
data_size: u64,
stride: u64,
) -> RttiResult<u64> {
let usable = data_size.saturating_sub(BYTEVEC_HEADER);
if byte_len > usable {
return Err(rtti_err!(
VecLen,
"RTTI vector length ({} bytes) exceeds its data block \
({} usable bytes) — corrupt length word",
byte_len,
usable
));
}
Ok(byte_len.checked_div(stride).unwrap_or(0))
}
pub(in crate::rtti) fn strong_counter_slot(
data: &BStack,
weak: bool,
data_off: NonNullOffset,
) -> RttiResult<(NonNullOffset, Option<NonNullOffset>)> {
if weak {
let ctrl = Offset::from_raw(read_u64(
data,
data_off.checked_add(CTRL_BACKPTR_OFFSET)?.as_u64(),
)?)
.to_non_null()
.ok_or_else(|| {
rtti_err!(
Malformed,
"RTTI: weak block has a null control back-pointer"
)
})?;
Ok((ctrl.checked_add(CTRL_STRONG_OFFSET)?, Some(ctrl)))
} else {
Ok((data_off.checked_add(RC_REFCOUNT_OFFSET)?, None))
}
}
pub(in crate::rtti) fn commit_weak_release<A: BStackRaiiAllocator>(
alloc: &A,
ctrl_off: NonNullOffset,
) -> RttiResult<()> {
let data = alloc.stack();
if refcount::fetch_sub(data, ctrl_off.checked_add(CTRL_WEAK_OFFSET)?, 1)? == 1 {
unsafe { alloc.free_many([BStackRange::new(ctrl_off.as_u64(), CONTROL_SIZE)])? };
}
Ok(())
}
pub(in crate::rtti) fn disc_mask(width: u8) -> u64 {
if width >= 8 {
u64::MAX
} else {
(1u64 << (width * 8)) - 1
}
}
pub(in crate::rtti) fn read_disc(data: &BStack, off: u64, width: u8) -> RttiResult<u64> {
let w = width as usize;
if w > 8 {
return Err(rtti_err!(
DiscWidth,
"RTTI enum discriminant width exceeds 8 bytes",
));
}
let mut b = [0u8; 8];
data.get_into(off, &mut b[..w])?;
Ok(u64::from_le_bytes(b))
}
impl RttiEnum {
pub(in crate::rtti) fn resolve_variant<'e>(
&'e self,
data: &BStack,
block_off: u64,
) -> RttiResult<(&'e RttiVariant, u64)> {
let raw = read_disc(
data,
add_off(block_off, self.disc_off as u64)?,
self.disc_width,
)?;
let mask = disc_mask(self.disc_width);
let variant = self
.variants
.iter()
.find(|v| (v.disc_value as u64) & mask == raw)
.ok_or_else(|| rtti_err!(NoVariant, "no RTTI variant for discriminant {}", raw))?;
let payload_base = add_off(block_off, self.payload_off as u64)?;
Ok((variant, payload_base))
}
}
pub(in crate::rtti) fn pop_n(results: &mut Vec<Value>, n: usize) -> RttiResult<Vec<Value>> {
let start = results
.len()
.checked_sub(n)
.ok_or_else(|| rtti_err!(Interpret, "RTTI interpret stack underflow"))?;
let mut v = results.split_off(start);
v.reverse();
Ok(v)
}
pub(in crate::rtti) fn pop_named(
results: &mut Vec<Value>,
names: &[String],
) -> RttiResult<Vec<(String, Value)>> {
let vals = pop_n(results, names.len())?;
Ok(names.iter().cloned().zip(vals).collect())
}