use std::sync::Arc;
use bytes::Bytes;
use super::{External, ObjectInfo, ScriptRef, SerializedFile, SerializedHeader, SerializedType};
use crate::error::Error;
use crate::files::{Parent, ParentKind};
use crate::limits::{Charge, Limits, Meter, MeteredVec, heap_cost};
use crate::once::ResultCell;
use crate::options::FileContext;
use crate::pin::CopyCounts;
use crate::raw::RawStr;
use crate::stream::{Endian, Reader, ReaderKind};
use crate::typetree::NodeList;
use crate::typetree::commonstring::CommonStrings;
use crate::typetree::parse::{is_blob_format, parse_blob, parse_old, string_to_null};
use crate::version::resolve_serialized;
impl SerializedFile {
pub fn parse(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
) -> Result<Arc<Self>, Error> {
Self::parse_with_reader(name, data, parent, meter, ctx, ReaderKind::Memory)
}
pub fn parse_with_reader(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
reader: ReaderKind,
) -> Result<Arc<Self>, Error> {
Self::parse_with_state(name, data, parent, meter, ctx, reader, &mut None)
}
#[expect(
clippy::too_many_lines,
reason = "format-gated metadata and charged file construction"
)]
pub(crate) fn parse_with_state(
name: RawStr,
data: Bytes,
parent: Option<Parent>,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
reader: ReaderKind,
endian: &mut Option<Endian>,
) -> Result<Arc<Self>, Error> {
let mut charge = meter.charge(heap_cost(
u64::try_from(std::mem::size_of::<Self>() + 16).unwrap_or(u64::MAX),
))?;
let mut p = Parser::new(&data, parent.as_ref(), meter, ctx, reader);
let header = p.header()?;
p.version = header.version;
p.r.set_endian(header.endian);
*endian = Some(header.endian);
let format = header.version;
let (unity_version, version) = if format >= 7 {
let own = string_to_null(&mut p.r, &data, meter)?;
let parent_engine = match parent.as_ref().map(|p| &p.kind) {
Some(ParentKind::Bundle { version_engine, .. }) => Some(version_engine),
_ => None,
};
let resolved =
resolve_serialized(&own, parent_engine, &ctx.version_policy(), &mut charge)?;
(Some(own), Some(resolved))
} else {
(None, None)
};
let target_platform = if format >= 8 {
Some(p.r.read_i32()?)
} else {
None
};
if format >= 13 {
p.enable_type_tree = p.r.read_bool()?;
}
let mut types = p.types(false)?;
let big_id_enabled = if (7..14).contains(&format) {
p.r.read_i32()?
} else {
0
};
let object_infos = p.objects(big_id_enabled, header.data_offset, &mut types)?;
let script_types = p.scripts()?;
let externals = p.externals()?;
let mut ref_types = if format >= 20 {
Some(p.types(true)?)
} else {
None
};
let head_roots = p.handlers.len();
if format >= 26 {
p.read_shared(&mut types, ref_types.as_mut())?;
}
let ref_types = ref_types.map(|t| keep(t, &mut charge)).transpose()?;
if !ctx.parse_typetree_enabled() {
p.enable_type_tree = false;
}
let user_information = if format >= 5 {
Some(string_to_null(&mut p.r, &data, meter)?)
} else {
None
};
let enable_type_tree = p.enable_type_tree && ctx.serialized_file_parse_typetree;
charge.absorb(p.kept);
let (object_order, by_path) = dict_order(&object_infos, meter)?;
let container_end = ctx
.eager_asset_bundle
.then(|| {
object_order
.as_slice()
.iter()
.filter_map(|index| object_infos.as_slice().get(*index as usize))
.find(|object| object.class_id == ASSET_BUNDLE)
.map(|object| object.byte_start + i128::from(object.byte_size))
})
.flatten();
let constructor_position = container_end.unwrap_or(p.r.position());
let types = keep(types, &mut charge)?;
let object_infos = keep(object_infos, &mut charge)?;
let script_types = keep(script_types, &mut charge)?;
let externals = keep(externals, &mut charge)?;
let object_order = keep(object_order, &mut charge)?;
let by_path = keep(by_path, &mut charge)?;
let copies = CopyCounts::new(p.trees.0, p.trees.1);
let head_handlers = p.handlers;
let file = Arc::new(Self {
changed: std::sync::atomic::AtomicBool::new(false),
edits: std::sync::Mutex::new(MeteredVec::new(meter)),
copies,
name,
data,
header,
unity_version,
version,
target_platform,
enable_type_tree,
big_id_enabled,
types,
ref_types,
head_handlers,
head_roots,
script_types,
externals,
pending_externals: std::sync::Mutex::new(MeteredVec::new(meter)),
user_information,
object_infos,
object_order,
by_path,
container: ResultCell::new(),
parent,
dependency_path: crate::files::DependencyPath::default(),
reader,
constructor_position,
charge,
ctx: ctx.clone(),
});
if container_end.is_some() {
file.container_at_load()?;
}
Ok(file)
}
}
const ASSET_BUNDLE: i32 = 142;
fn keep<T>(table: MeteredVec<T>, charge: &mut Charge) -> Result<Box<[T]>, Error> {
let (b, c) = table.into_boxed_slice()?;
charge.absorb(c);
Ok(b)
}
pub(super) struct Parser<'a> {
pub(super) r: Reader<'a>,
pub(super) data: &'a Bytes,
pinned: u64,
trees: (u64, u64),
pub(super) meter: &'a Arc<Meter>,
pub(super) limits: &'a Limits,
pub(super) common: Option<&'a CommonStrings>,
pub(super) version: u32,
enable_type_tree: bool,
kept: Charge,
pub(super) handlers: MeteredVec<super::head::Handler>,
}
impl<'a> Parser<'a> {
pub(super) fn new(
data: &'a Bytes,
parent: Option<&Parent>,
meter: &'a Arc<Meter>,
ctx: &'a FileContext,
reader: ReaderKind,
) -> Self {
Self {
r: Reader::with_kind(data, Endian::Big, reader),
data,
pinned: super::pinned(parent, data),
trees: (0, 0),
meter,
limits: &ctx.limits,
common: ctx.providers.common_strings(),
version: 0,
enable_type_tree: true,
kept: Charge::zero(meter),
handlers: MeteredVec::new(meter),
}
}
}
impl Parser<'_> {
fn header(&mut self) -> Result<SerializedHeader, Error> {
let r = &mut self.r;
let [
meta0,
meta1,
meta2,
meta3,
file0,
file1,
file2,
file3,
ver0,
ver1,
ver2,
ver3,
off0,
off1,
off2,
off3,
] = r.read_array::<16>()?;
let mut metadata_size = u32::from_be_bytes([meta0, meta1, meta2, meta3]);
let mut file_size = i64::from(u32::from_be_bytes([file0, file1, file2, file3]));
let version = u32::from_be_bytes([ver0, ver1, ver2, ver3]);
let mut data_offset = i64::from(u32::from_be_bytes([off0, off1, off2, off3]));
let (endian, reserved, unknown);
let order = |big: bool| if big { Endian::Big } else { Endian::Little };
if version >= 9 {
endian = order(r.read_bool()?);
let got = r.read_bytes_short(3);
let mut three = [0u8; 3];
for (d, s) in three.iter_mut().zip(got) {
*d = *s;
}
reserved = Some(three);
if version >= 22 {
metadata_size = r.read_u32()?;
file_size = r.read_i64()?;
data_offset = r.read_i64()?;
unknown = r.read_i64()?;
} else {
unknown = 0;
}
} else {
r.set_position(i128::from(file_size) - i128::from(metadata_size))?;
endian = order(r.read_bool()?);
reserved = None;
unknown = 0;
}
Ok(SerializedHeader {
metadata_size,
file_size,
version,
data_offset,
endian,
reserved,
unknown,
})
}
fn scripts(&mut self) -> Result<MeteredVec<ScriptRef>, Error> {
let mut scripts = MeteredVec::new(self.meter);
if self.version < 11 {
return Ok(scripts);
}
for _ in 0..self.r.read_i32()?.max(0) {
let file_index = self.r.read_i32()?;
let identifier = if self.version < 14 {
i64::from(self.r.read_i32()?)
} else {
self.r.align(4)?;
self.r.read_i64()?
};
scripts.push(ScriptRef {
file_index,
identifier,
})?;
}
Ok(scripts)
}
fn externals(&mut self) -> Result<MeteredVec<External>, Error> {
let mut externals = MeteredVec::new(self.meter);
for _ in 0..self.r.read_i32()?.max(0) {
let temp_empty = if self.version >= 6 {
Some(string_to_null(&mut self.r, self.data, self.meter)?)
} else {
None
};
let (guid, kind) = if self.version >= 5 {
(Some(self.r.read_short_array()), Some(self.r.read_i32()?))
} else {
(None, None)
};
let path = string_to_null(&mut self.r, self.data, self.meter)?;
externals.push(External {
temp_empty,
guid,
kind,
path,
})?;
}
Ok(externals)
}
fn types(&mut self, is_ref: bool) -> Result<MeteredVec<SerializedType>, Error> {
let mut types = MeteredVec::new(self.meter);
for _ in 0..self.r.read_i32()?.max(0) {
let t = self.serialized_type(is_ref)?;
types.push(t)?;
}
Ok(types)
}
fn serialized_type(&mut self, is_ref: bool) -> Result<SerializedType, Error> {
let v = self.version;
let class_id = self.r.read_i32()?;
let mut t = SerializedType::new(class_id, None);
if v >= 16 {
t.is_stripped_type = Some(self.r.read_bool()?);
}
if v >= 17 {
t.script_type_index = self.r.read_i16()?;
}
if v >= 13 {
if (is_ref && t.script_type_index >= 0)
|| (v < 16 && class_id < 0)
|| (v >= 16 && class_id == 114)
{
t.script_id = Some(self.r.read_short_array());
}
t.old_type_hash = Some(self.r.read_short_array());
}
if self.enable_type_tree {
if v >= 23 {
let handler = self.head_handler()?;
t.nodes = handler.nodes();
self.handlers.push(handler)?;
} else {
let mut rows = if is_blob_format(v) {
parse_blob(
&mut self.r,
self.data,
v,
self.meter,
self.limits,
self.common,
)?
} else {
parse_old(&mut self.r, self.data, v, self.meter, self.limits)?
};
self.copy_tree_strings(&mut rows);
t.nodes = Some(NodeList::from_rows(rows)?.into_shared()?);
}
if v >= 21 {
if is_ref {
t.class_name = Some(string_to_null(&mut self.r, self.data, self.meter)?);
t.namespace = Some(string_to_null(&mut self.r, self.data, self.meter)?);
t.assembly = Some(string_to_null(&mut self.r, self.data, self.meter)?);
} else {
let deps = self.r.read_i32_array(self.meter)?;
let (deps, c) = deps.into_boxed_slice()?;
self.kept.absorb(c);
t.type_dependencies = Some(deps);
}
}
}
Ok(t)
}
pub(super) fn copy_tree_strings(&mut self, rows: &mut MeteredVec<crate::typetree::NodeRow>) {
let n = crate::pin::copy_out(rows, self.data, self.pinned, self.meter);
if n > 0 {
self.trees = (
self.trees.0.saturating_add(1),
self.trees.1.saturating_add(n),
);
}
}
fn objects(
&mut self,
big_id_enabled: i32,
data_offset: i64,
types: &mut MeteredVec<SerializedType>,
) -> Result<MeteredVec<ObjectInfo>, Error> {
let v = self.version;
let mut objects = MeteredVec::new(self.meter);
let mut by_class: Option<TypesByClass> = None;
for _ in 0..self.r.read_i32()?.max(0) {
let r = &mut self.r;
let path_id = if big_id_enabled != 0 {
r.read_i64()?
} else if v < 14 {
i64::from(r.read_i32()?)
} else {
r.align(4)?;
r.read_i64()?
};
let stored = if v >= 22 {
i128::from(r.read_i64()?)
} else {
i128::from(r.read_u32()?)
};
let byte_start = stored + i128::from(data_offset);
let byte_size = r.read_u32()?;
let type_id = r.read_i32()?;
let (class_id, type_index) = if v < 16 {
let class_id = i32::from(r.read_u16()?);
let by_class = match &mut by_class {
Some(t) => t,
none => none.insert(TypesByClass::new(types.as_slice(), self.meter)?),
};
(class_id, by_class.first(type_id))
} else {
let len = types.len();
let index = if type_id < 0 {
len.checked_sub(usize::try_from(type_id.unsigned_abs()).unwrap_or(usize::MAX))
} else {
usize::try_from(type_id).ok().filter(|i| *i < len)
};
let index = index.ok_or(Error::TypeIndex {
index: type_id,
len,
})?;
let class_id = types.as_slice().get(index).map_or(0, |t| t.class_id);
(class_id, Some(index))
};
let is_destroyed = if v < 11 { Some(r.read_u16()?) } else { None };
let script_type_index = if (11..17).contains(&v) {
let i = r.read_i16()?;
if let Some(t) = type_index.and_then(|t| types.as_mut_slice().get_mut(t)) {
t.script_type_index = i;
}
Some(i)
} else {
None
};
let is_stripped = if v == 15 || v == 16 {
Some(r.read_i8()?)
} else {
None
};
objects.push(ObjectInfo {
path_id,
byte_start,
byte_size,
type_id,
class_id,
type_index,
is_destroyed,
is_stripped,
script_type_index,
})?;
}
Ok(objects)
}
}
struct TypesByClass {
pairs: MeteredVec<(i32, u32)>,
}
impl TypesByClass {
fn new(types: &[SerializedType], meter: &Arc<Meter>) -> Result<Self, Error> {
let bytes = types
.len()
.saturating_mul(std::mem::size_of::<(i32, u32)>());
meter.count_decode(u64::try_from(bytes).unwrap_or(u64::MAX))?;
let mut pairs = MeteredVec::with_capacity(meter, types.len())?;
for (i, t) in types.iter().enumerate() {
pairs.push((t.class_id, u32::try_from(i).unwrap_or(u32::MAX)))?;
}
pairs.as_mut_slice().sort_unstable();
Ok(Self { pairs })
}
fn first(&self, class_id: i32) -> Option<usize> {
let pairs = self.pairs.as_slice();
let at = pairs.partition_point(|(c, _)| *c < class_id);
pairs
.get(at)
.filter(|(c, _)| *c == class_id)
.and_then(|(_, i)| usize::try_from(*i).ok())
}
}
fn dict_order(
infos: &MeteredVec<ObjectInfo>,
meter: &Arc<Meter>,
) -> Result<(MeteredVec<u32>, MeteredVec<u32>), Error> {
let rows = infos.as_slice();
let n = rows.len();
let index = |i: usize| u32::try_from(i).unwrap_or(u32::MAX);
let path = |i: &u32| {
usize::try_from(*i)
.ok()
.and_then(|i| rows.get(i))
.map_or(i64::MIN, |o| o.path_id)
};
let mut perm: MeteredVec<u32> = MeteredVec::with_capacity(meter, n)?;
for i in 0..n {
perm.push(index(i))?;
}
perm.as_mut_slice().sort_unstable_by_key(|i| (path(i), *i));
let mut by_path: MeteredVec<u32> = MeteredVec::new(meter);
let mut groups: MeteredVec<(u32, u32)> = MeteredVec::new(meter);
let mut at = 0;
let all = perm.as_slice();
while let Some(first) = all.get(at) {
let key = path(first);
let mut last = *first;
let mut end = at + 1;
while let Some(next) = all.get(end).filter(|i| path(i) == key) {
last = *next;
end += 1;
}
by_path.push(last)?;
groups.push((*first, last))?;
at = end;
}
drop(perm);
groups.as_mut_slice().sort_unstable_by_key(|g| g.0);
let mut order: MeteredVec<u32> = MeteredVec::with_capacity(meter, groups.len())?;
for (_, last) in groups.as_slice() {
order.push(*last)?;
}
Ok((order, by_path))
}