read serialized file tables

1 files changed, 5 insertions, 133 deletions

diff --git a/src/main.rs b/src/main.rs
index a0b35c3..4d91578 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,14 +1,5 @@
-use log::debug;
-use std::{
-    env::args,
-    fs::File,
-    io::{BufReader, Cursor, Read},
-};
-use unity_tools::{
-    common_strings::COMMON_STRINGS,
-    helper::{Endianness, ReadExt},
-    unityfs::UnityFS,
-};
+use std::{env::args, fs::File, io::BufReader};
+use unity_tools::{serialized_file::read_serialized_file, unityfs::UnityFS};
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
@@ -19,134 +10,15 @@ fn main() -> anyhow::Result<()> {
         if node.name.ends_with(".resource") || node.name.ends_with("resS") {
             continue;
         }
-        let mut cab = fs.read(&node)?;
+        let cab = fs.read(&node)?;
         // let mut writer = File::create(format!("/tmp/{}", node.name))?;
         // std::io::copy(&mut cab, &mut writer)?;
         // continue;
 
-        let mut metadata_size = cab.read_u32_be()?;
-        let mut file_size = cab.read_u32_be()? as u64;
-        let format = cab.read_u32_be()?;
-        let mut data_offset = cab.read_u32_be()? as u64;
+        let file = read_serialized_file(cab)?;
+        eprintln!("{file:#?}");
 
-        debug!("format={format}");
-
-        assert!(format >= 9);
-        let e = match cab.read_u32_be()? {
-            0 => Endianness::Little,
-            _ => Endianness::Big,
-        };
-        debug!("endianess={e:?}");
-
-        if format >= 22 {
-            metadata_size = cab.read_u32(e)?;
-            file_size = cab.read_u64(e)?;
-            data_offset = cab.read_u64(e)?;
-            cab.read_u64(e)?;
-        }
-        debug!("metadata_size={metadata_size}");
-        debug!("file_size={file_size}");
-        debug!("data_offset={data_offset}");
-
-        let generator_version = cab.read_cstr()?;
-        let target_platform = cab.read_u32_le()?;
-        debug!("generator_version={generator_version:?}");
-        debug!("target_platform={target_platform}");
-
-        let has_type_trees = cab.read_u8()? != 0;
-        let num_types = cab.read_u32(e)?;
-        debug!("has_type_trees={has_type_trees:?}");
-        debug!("num_types={num_types}");
-
-        for _ in 0..num_types {
-            let class_id = cab.read_i32(e)?;
-            let stripped_type = cab.read_u8()? != 0;
-            let script_index = cab.read_i16(e)?;
-            let mut script_id = 0;
-            // TODO reftype
-            if class_id == 114 {
-                script_id = cab.read_u128_be()?;
-            }
-            let _old_hash = cab.read_u128_be()?;
-
-            eprintln!("class_id={class_id}");
-            eprintln!("stripped_type={stripped_type}");
-            eprintln!("script_index={script_index}");
-            eprintln!("script_id={script_id}");
-
-            if has_type_trees {
-                let num_nodes = cab.read_u32(e)?;
-                let size = cab.read_u32(e)?;
-                eprintln!("tree:num_nodes={num_nodes}");
-                eprintln!("tree:size={size}");
-
-                let mut node_data = vec![0u8; num_nodes as usize * 32];
-                cab.read_exact(&mut node_data)?;
-                let mut node_data = Cursor::new(node_data);
-                let mut string_data = vec![0u8; size as usize];
-                cab.read_exact(&mut string_data)?;
-
-                let get_string = |off: u32| {
-                    let data = if off & 0x80000000 != 0 {
-                        let off = off & 0x7fffffff;
-                        &COMMON_STRINGS[(off & 0x7fffffff) as usize..]
-                    } else {
-                        &string_data[off as usize..]
-                    };
-                    String::from_utf8(
-                        data.iter()
-                            .copied()
-                            .take_while(|e| *e != 0)
-                            .collect::<Vec<u8>>(),
-                    )
-                };
-
-                let mut nodes = Vec::new();
-                for _ in 0..num_nodes {
-                    nodes.push(TypeTreeNode {
-                        version: node_data.read_u16(e)?,
-                        level: node_data.read_u8()?,
-                        type_flags: node_data.read_u8()?,
-                        type_string: get_string(node_data.read_u32(e)?)?,
-                        name_string: get_string(node_data.read_u32(e)?)?,
-                        byte_size: node_data.read_i32(e)?,
-                        index: node_data.read_i32(e)?,
-                        flags: node_data.read_i32(e)?,
-                        ref_type_hash: node_data.read_u64(e)?,
-                    });
-                }
-                eprintln!("{nodes:#?}");
-
-                if format >= 21 {
-                    let num_deps = cab.read_u32(e)?;
-                    for _ in 0..num_deps {
-                        cab.read_u32(e)?;
-                    }
-                }
-            }
-
-            if format > 21 {
-                cab.read_u32_be()?;
-            }
-        }
-
-        // let num_objects = cab.read_u32_le()?;
-        // debug!("num_objects={num_objects}");
-        // for _ in 0..num_objects {}
     }
 
     Ok(())
 }
-
-#[derive(Debug)]
-struct TypeTreeNode {
-    version: u16,
-    level: u8,
-    type_flags: u8,
-    type_string: String,
-    name_string: String,
-    byte_size: i32,
-    index: i32,
-    flags: i32,
-    ref_type_hash: u64,
-}