hxuanyu/cs2-dumper
1
0
Fork 0
mirror of https://github.com/a2x/cs2-dumper.git synced 2025-04-24 16:15:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

Reorganize schema system structures into separate files

Browse Source
This commit is contained in:
a2x 2024-04-21 00:31:51 +10:00
parent 13b764854e
commit d0c40c50cd
22 changed files with 325 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/analysis/buttons.rs
View File

@ -51,7 +51,7 @@ fn read_buttons(
((cur_button.address() - module.base) + offset_of!(KeyButton.state) as i64) as u32;
debug!(
"found button: {} at {:#X} ({} + {:#X})",
"found button: {} @ {:#X} ({} + {:#X})",
name,
value as u64 + module.base.to_umem(),
module.name,
@ -63,7 +63,6 @@ fn read_buttons(
cur_button = button.next;
}
// Sort buttons by name.
buttons.sort_unstable_by(|a, b| a.name.cmp(&b.name));
Ok(buttons)

4
src/analysis/interfaces.rs
View File

@ -58,10 +58,11 @@ fn read_interfaces(
while !cur_reg.is_null() {
let reg = cur_reg.read(process)?;
let name = reg.name.read_string(process)?.to_string();
let value = (reg.create_fn.address() - module.base) as u32;
debug!(
"found interface: {} at {:#X} ({} + {:#X})",
"found interface: {} @ {:#X} ({} + {:#X})",
name,
value as u64 + module.base.to_umem(),
module.name,
@ -73,7 +74,6 @@ fn read_interfaces(
cur_reg = reg.next;
}
// Sort interfaces by name.
ifaces.sort_unstable_by(|a, b| a.name.cmp(&b.name));
Ok(ifaces)

1
src/analysis/mod.rs
View File

@ -12,7 +12,6 @@ mod interfaces;
mod offsets;
mod schemas;
#[derive(Debug)]
pub struct AnalysisResult {
pub buttons: Vec<Button>,
pub interfaces: InterfaceMap,

2
src/analysis/offsets.rs
View File

@ -53,7 +53,7 @@ macro_rules! pattern_map {
for (name, value) in &map {
debug!(
"found offset: {} at {:#X} ({}.dll + {:#X})",
"found offset: {} @ {:#X} ({}.dll + {:#X})",
name,
*value as u64 + view.optional_header().ImageBase,
stringify!($module),

32
src/analysis/schemas.rs
View File

@ -42,7 +42,7 @@ pub struct ClassField {
pub struct Enum {
pub name: String,
pub alignment: u8,
pub size: i16,
pub size: u16,
pub members: Vec<EnumMember>,
}
@ -114,7 +114,7 @@ fn read_class_binding(
let metadata = read_class_binding_metadata(process, &binding)?;
debug!(
"found class: {} at {:#X} (module name: {}) (parent name: {:?}) (metadata count: {}) (fields count: {})",
"found class: {} @ {:#X} (module name: {}) (parent name: {:?}) (metadata count: {}) (fields count: {})",
name,
binding_ptr.to_umem(),
module_name,
@ -140,7 +140,7 @@ fn read_class_binding_fields(
return Ok(Vec::new());
}
(0..binding.num_fields).try_fold(Vec::new(), |mut acc, i| {
(0..binding.field_count).try_fold(Vec::new(), |mut acc, i| {
let field = binding.fields.at(i as _).read(process)?;
if field.schema_type.is_null() {
@ -156,7 +156,7 @@ fn read_class_binding_fields(
acc.push(ClassField {
name,
type_name,
offset: field.offset,
offset: field.single_inheritance_offset,
});
Ok(acc)
@ -171,24 +171,28 @@ fn read_class_binding_metadata(
return Ok(Vec::new());
}
(0..binding.num_static_metadata).try_fold(Vec::new(), |mut acc, i| {
(0..binding.static_metadata_count).try_fold(Vec::new(), |mut acc, i| {
let metadata = binding.static_metadata.at(i as _).read(process)?;
if metadata.network_value.is_null() {
if metadata.data.is_null() {
return Ok(acc);
}
let name = metadata.name.read_string(process)?.to_string();
let network_value = metadata.network_value.read(process)?;
let network_value = metadata.data.read(process)?;
let metadata = match name.as_str() {
"MNetworkChangeCallback" => unsafe {
let name = network_value.u.name_ptr.read_string(process)?.to_string();
let name = network_value
.value
.name_ptr
.read_string(process)?
.to_string();
ClassMetadata::NetworkChangeCallback { name }
},
"MNetworkVarNames" => unsafe {
let var_value = network_value.u.var_value;
let var_value = network_value.value.var_value;
let name = var_value.name.read_string(process)?.to_string();
let type_name = var_value.type_name.read_string(process)?.replace(" ", "");
@ -214,7 +218,7 @@ fn read_enum_binding(
let members = read_enum_binding_members(process, &binding)?;
debug!(
"found enum: {} at {:#X} (alignment: {}) (members count: {})",
"found enum: {} @ {:#X} (alignment: {}) (members count: {})",
name,
binding_ptr.to_umem(),
binding.alignment,
@ -224,7 +228,7 @@ fn read_enum_binding(
Ok(Enum {
name,
alignment: binding.alignment,
size: binding.num_enumerators,
size: binding.enumerator_count,
members,
})
}
@ -237,13 +241,13 @@ fn read_enum_binding_members(
return Ok(Vec::new());
}
(0..binding.num_enumerators).try_fold(Vec::new(), |mut acc, i| {
(0..binding.enumerator_count).try_fold(Vec::new(), |mut acc, i| {
let enumerator = binding.enumerators.at(i as _).read(process)?;
let name = enumerator.name.read_string(process)?.to_string();
acc.push(EnumMember {
name,
value: unsafe { enumerator.u.ulong } as i64,
value: unsafe { enumerator.value.ulong } as i64,
});
Ok(acc)
@ -307,7 +311,7 @@ fn read_type_scopes(
}
debug!(
"found type scope: {} at {:#X} (classes count: {}) (enums count: {})",
"found type scope: {} @ {:#X} (classes count: {}) (enums count: {})",
module_name,
type_scope_ptr.to_umem(),
classes.len(),

1
src/mem.rs
View File

@ -1,7 +1,6 @@
use memflow::types::{Pointer, PrimitiveAddress};
pub trait PointerExt {
/// Returns `true` if the pointer is null.
fn is_null(&self) -> bool;
}

7
src/output/mod.rs
View File

@ -6,7 +6,6 @@ use chrono::{DateTime, Utc};
use memflow::prelude::v1::*;
use serde::Serialize;
use serde_json::json;
use formatter::Formatter;
@ -20,8 +19,6 @@ mod interfaces;
mod offsets;
mod schemas;
#[derive(Serialize)]
#[serde(rename_all = "snake_case")]
enum Item<'a> {
Buttons(&'a Vec<Button>),
Interfaces(&'a InterfaceMap),
@ -30,8 +27,8 @@ enum Item<'a> {
}
impl<'a> Item<'a> {
fn write(&self, fmt: &mut Formatter<'a>, file_ext: &str) -> fmt::Result {
match file_ext {
fn write(&self, fmt: &mut Formatter<'a>, file_type: &str) -> fmt::Result {
match file_type {
"cs" => self.write_cs(fmt),
"hpp" => self.write_hpp(fmt),
"json" => self.write_json(fmt),

263
src/source2/schema_system/mod.rs
View File

@ -1,244 +1,21 @@
use std::ffi::c_char;
pub use schema_base_class_info_data::*;
pub use schema_class_field_data::*;
pub use schema_class_info_data::*;
pub use schema_enum_info_data::*;
pub use schema_enumerator_info_data::*;
pub use schema_metadata_entry_data::*;
pub use schema_static_field_data::*;
pub use schema_system::*;
pub use schema_system_type_scope::*;
pub use schema_type::*;
use memflow::prelude::v1::*;
use super::{UtlTsHash, UtlVector};
pub type SchemaClassBinding = SchemaClassInfoData;
pub type SchemaEnumBinding = SchemaEnumInfoData;
pub type SchemaTypeDeclaredClass = SchemaType;
pub type SchemaTypeDeclaredEnum = SchemaType;
#[repr(u8)]
pub enum SchemaAtomicCategory {
Basic = 0,
T,
CollectionOfT,
TF,
TT,
TTF,
I,
None,
}
#[repr(u8)]
pub enum SchemaTypeCategory {
BuiltIn = 0,
Ptr,
Bitfield,
FixedArray,
Atomic,
DeclaredClass,
DeclaredEnum,
None,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaArrayT {
pub array_size: u32, // 0x0000
pad_0004: [u8; 0x4], // 0x0004
pub element: Pointer64<SchemaType>, // 0x0008
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicI {
pad_0000: [u8; 0x10], // 0x0000
pub value: u64, // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicT {
pub element: Pointer64<SchemaType>, // 0x0000
pad_0008: [u8; 0x8], // 0x0008
pub template: Pointer64<SchemaType>, // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTT {
pad_0000: [u8; 0x10], // 0x0000
pub templates: [Pointer64<SchemaType>; 2], // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTF {
pad_0000: [u8; 0x10], // 0x0000
pub template: Pointer64<SchemaType>, // 0x0010
pub size: i32, // 0x0018
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTTF {
pad_0000: [u8; 0x10], // 0x0000
pub templates: [Pointer64<SchemaType>; 2], // 0x0010
pub size: i32, // 0x0020
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaBaseClassInfoData {
pub offset: i32, // 0x0000
pad_0004: [u8; 0x4], // 0x0004
pub prev: Pointer64<SchemaClassInfoData>, // 0x0008
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaClassFieldData {
pub name: Pointer64<ReprCString>, // 0x0000
pub schema_type: Pointer64<SchemaType>, // 0x0008
pub offset: i32, // 0x0010
pub num_metadata: i32, // 0x0014
pub metadata: Pointer64<SchemaMetadataEntryData>, // 0x0018
}
#[rustfmt::skip]
#[derive(Pod)]
#[repr(C)]
pub struct SchemaClassInfoData {
pub base: Pointer64<SchemaClassInfoData>, // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub module_name: Pointer64<ReprCString>, // 0x0010
pub size: i32, // 0x0018
pub num_fields: i16, // 0x001C
pub num_static_fields: i16, // 0x001E
pub num_static_metadata: i16, // 0x0020
pub alignment: u8, // 0x0022
pub has_base_class: u8, // 0x0023
pub total_class_size: i16, // 0x0024
pub derived_class_size: i16, // 0x0026
pub fields: Pointer64<[SchemaClassFieldData]>, // 0x0028
pub static_fields: Pointer64<[SchemaStaticFieldData]>, // 0x0030
pub base_classes: Pointer64<SchemaBaseClassInfoData>, // 0x0038
pad_0040: [u8; 0x8], // 0x0040
pub static_metadata: Pointer64<[SchemaMetadataEntryData]>, // 0x0048
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0050
pub schema_type: Pointer64<SchemaType>, // 0x0058
pad_0060: [u8; 0x10], // 0x0060
}
#[rustfmt::skip]
#[derive(Pod)]
#[repr(C)]
pub struct SchemaEnumInfoData {
pub base: Pointer64<SchemaEnumInfoData>, // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub module_name: Pointer64<ReprCString>, // 0x0010
pub size: u8, // 0x0018
pub alignment: u8, // 0x0019
pad_001a: u16, // 0x001A
pub num_enumerators: i16, // 0x001C
pub num_static_metadata: i16, // 0x001E
pub enumerators: Pointer64<[SchemaEnumeratorInfoData]>, // 0x0020
pub static_metadata: Pointer64<SchemaMetadataEntryData>, // 0x0028
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0030
pad_0038: [u8; 0x10], // 0x0038
}
#[repr(C)]
pub struct SchemaEnumeratorInfoData {
pub name: Pointer64<ReprCString>, // 0x0000
pub u: SchemaEnumeratorInfoDataUnion, // 0x0008
pub num_metadata: u32, // 0x0010
pub metadata: Pointer64<SchemaMetadataEntryData>, // 0x0018
}
unsafe impl Pod for SchemaEnumeratorInfoData {}
#[repr(C)]
pub union SchemaEnumeratorInfoDataUnion {
pub uchar: u8,
pub ushort: u16,
pub uint: u32,
pub ulong: u64,
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaMetadataEntryData {
pub name: Pointer64<ReprCString>, // 0x0000
pub network_value: Pointer64<SchemaNetworkValue>, // 0x0008
}
#[repr(C)]
pub struct SchemaNetworkValue {
pub u: SchemaNetworkValueUnion, // 0x0000
}
unsafe impl Pod for SchemaNetworkValue {}
#[repr(C)]
pub union SchemaNetworkValueUnion {
pub name_ptr: Pointer64<ReprCString>,
pub int_value: i32,
pub float_value: f32,
pub ptr: Pointer64<()>,
pub var_value: SchemaVarName,
pub name_value: [c_char; 32],
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaStaticFieldData {
pub name: Pointer64<ReprCString>, // 0x0000
pub type_: Pointer64<SchemaType>, // 0x0008
pub instance: Pointer64<()>, // 0x0010
pad_0018: [u8; 0x10], // 0x0018
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaSystem {
pad_0000: [u8; 0x190], // 0x0000
pub type_scopes: UtlVector<Pointer64<SchemaSystemTypeScope>>, // 0x0190
pad_01a0: [u8; 0x120], // 0x01A0
pub num_registrations: u32, // 0x02C0
pad_02c4: [u8; 0x4], // 0x02C4
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaSystemTypeScope {
pad_0000: [u8; 0x8], // 0x0000
pub name: [c_char; 256], // 0x0008
pub global_scope: Pointer64<SchemaSystemTypeScope>, // 0x0108
pad_0110: [u8; 0x4B0], // 0x0110
pub class_bindings: UtlTsHash<Pointer64<SchemaClassBinding>>, // 0x05C0
pub enum_bindings: UtlTsHash<Pointer64<SchemaEnumBinding>>, // 0x2E50
}
#[repr(C)]
pub struct SchemaType {
pad_0000: [u8; 0x8], // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0010
pub type_category: SchemaTypeCategory, // 0x0018
pub atomic_category: SchemaAtomicCategory, // 0x0019
pub u: SchemaTypeUnion, // 0x0020
}
unsafe impl Pod for SchemaType {}
pub union SchemaTypeUnion {
pub schema_type: Pointer64<SchemaType>,
pub class_binding: Pointer64<SchemaClassBinding>,
pub enum_binding: Pointer64<SchemaEnumBinding>,
pub array: SchemaArrayT,
pub atomic: SchemaAtomicT,
pub atomic_tt: SchemaAtomicTT,
pub atomic_tf: SchemaAtomicTF,
pub atomic_ttf: SchemaAtomicTTF,
pub atomic_i: SchemaAtomicI,
}
#[derive(Pod, Clone, Copy)]
#[repr(C)]
pub struct SchemaVarName {
pub name: Pointer64<ReprCString>, // 0x0000
pub type_name: Pointer64<ReprCString>, // 0x0008
}
pub mod schema_base_class_info_data;
pub mod schema_class_field_data;
pub mod schema_class_info_data;
pub mod schema_enum_info_data;
pub mod schema_enumerator_info_data;
pub mod schema_metadata_entry_data;
pub mod schema_static_field_data;
pub mod schema_system;
pub mod schema_system_type_scope;
pub mod schema_type;

11
src/source2/schema_system/schema_base_class_info_data.rs Normal file
View File

@ -0,0 +1,11 @@
use memflow::prelude::v1::*;
use super::SchemaClassInfoData;
#[derive(Pod)]
#[repr(C)]
pub struct SchemaBaseClassInfoData {
pub offset: u32, // 0x0000
pad_0004: [u8; 4], // 0x0004
pub prev: Pointer64<SchemaClassInfoData>, // 0x0008
}

13
src/source2/schema_system/schema_class_field_data.rs Normal file
View File

@ -0,0 +1,13 @@
use memflow::prelude::v1::*;
use super::{SchemaMetadataEntryData, SchemaType};
#[derive(Pod)]
#[repr(C)]
pub struct SchemaClassFieldData {
pub name: Pointer64<ReprCString>, // 0x0000
pub schema_type: Pointer64<SchemaType>, // 0x0008
pub single_inheritance_offset: i32, // 0x0010
pub static_metadata_count: i32, // 0x0014
pub static_metadata: Pointer64<SchemaMetadataEntryData>, // 0x0018
}

30
src/source2/schema_system/schema_class_info_data.rs Normal file
View File

@ -0,0 +1,30 @@
use memflow::prelude::v1::*;
use super::*;
pub type SchemaClassBinding = SchemaClassInfoData;
#[rustfmt::skip]
#[derive(Pod)]
#[repr(C)]
pub struct SchemaClassInfoData {
pub base: Pointer64<SchemaClassInfoData>, // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub module_name: Pointer64<ReprCString>, // 0x0010
pub size: i32, // 0x0018
pub field_count: u16, // 0x001C
pub static_field_count: u16, // 0x001E
pub static_metadata_count: u16, // 0x0020
pub alignment: u8, // 0x0022
pub base_class_count: u8, // 0x0023
pub multiple_inheritance_depth: u16, // 0x0024
pub single_inheritance_depth: u16, // 0x0026
pub fields: Pointer64<[SchemaClassFieldData]>, // 0x0028
pub static_fields: Pointer64<[SchemaStaticFieldData]>, // 0x0030
pub base_classes: Pointer64<SchemaBaseClassInfoData>, // 0x0038
pad_0040: [u8; 0x8], // 0x0040
pub static_metadata: Pointer64<[SchemaMetadataEntryData]>, // 0x0048
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0050
pub schema_type: Pointer64<SchemaType>, // 0x0058
pad_0060: [u8; 0x10], // 0x0060
}

24
src/source2/schema_system/schema_enum_info_data.rs Normal file
View File

@ -0,0 +1,24 @@
use memflow::prelude::v1::*;
use super::{SchemaEnumeratorInfoData, SchemaMetadataEntryData, SchemaSystemTypeScope};
pub type SchemaEnumBinding = SchemaEnumInfoData;
#[rustfmt::skip]
#[derive(Pod)]
#[repr(C)]
pub struct SchemaEnumInfoData {
pub base: Pointer64<SchemaEnumInfoData>, // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub module_name: Pointer64<ReprCString>, // 0x0010
pub size: u8, // 0x0018
pub alignment: u8, // 0x0019
pub flags: u16, // 0x001A
pub enumerator_count: u16, // 0x001C
pub static_metadata_count: u16, // 0x001E
pub enumerators: Pointer64<[SchemaEnumeratorInfoData]>, // 0x0020
pub static_metadata: Pointer64<SchemaMetadataEntryData>, // 0x0028
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0030
pub min_enumerator_value: i64, // 0x0038
pub max_enumerator_value: i64, // 0x0040
}

23
src/source2/schema_system/schema_enumerator_info_data.rs Normal file
View File

@ -0,0 +1,23 @@
use memflow::prelude::v1::*;
use super::SchemaMetadataEntryData;
#[derive(Pod)]
#[repr(C)]
pub struct SchemaEnumeratorInfoData {
pub name: Pointer64<ReprCString>, // 0x0000
pub value: SchemaEnumeratorInfoDataUnion, // 0x0008
pub static_metadata_count: i32, // 0x0010
pad_0014: [u8; 0x4], // 0x0014
pub static_metadata: Pointer64<SchemaMetadataEntryData>, // 0x0018
}
#[repr(C)]
pub union SchemaEnumeratorInfoDataUnion {
pub uchar: u8,
pub ushort: u16,
pub uint: u32,
pub ulong: u64,
}
unsafe impl Pod for SchemaEnumeratorInfoDataUnion {}

35
src/source2/schema_system/schema_metadata_entry_data.rs Normal file
View File

@ -0,0 +1,35 @@
use std::ffi::c_char;
use memflow::prelude::v1::*;
#[derive(Pod)]
#[repr(C)]
pub struct SchemaMetadataEntryData {
pub name: Pointer64<ReprCString>, // 0x0000
pub data: Pointer64<SchemaNetworkValue>, // 0x0008
}
#[derive(Pod)]
#[repr(C)]
pub struct SchemaNetworkValue {
pub value: SchemaNetworkValueUnion, // 0x0000
}
#[repr(C)]
pub union SchemaNetworkValueUnion {
pub name_ptr: Pointer64<ReprCString>,
pub int_value: i32,
pub float_value: f32,
pub ptr: Pointer64<()>,
pub var_value: SchemaVarName,
pub name_value: [c_char; 32],
}
unsafe impl Pod for SchemaNetworkValueUnion {}
#[derive(Clone, Copy, Pod)]
#[repr(C)]
pub struct SchemaVarName {
pub name: Pointer64<ReprCString>, // 0x0000
pub type_name: Pointer64<ReprCString>, // 0x0008
}

14
src/source2/schema_system/schema_static_field_data.rs Normal file
View File

@ -0,0 +1,14 @@
use memflow::prelude::v1::*;
use super::{SchemaMetadataEntryData, SchemaType};
#[derive(Pod)]
#[repr(C)]
pub struct SchemaStaticFieldData {
pub name: Pointer64<ReprCString>, // 0x0000
pub type_: Pointer64<SchemaType>, // 0x0008
pub instance: Pointer64<()>, // 0x0010
pub static_metadata_count: i32, // 0x0018
pad_001c: [u8; 0x4], // 0x001C
pub static_metadata: Pointer64<SchemaMetadataEntryData>, // 0x0020
}

15
src/source2/schema_system/schema_system.rs Normal file
View File

@ -0,0 +1,15 @@
use memflow::prelude::v1::*;
use super::SchemaSystemTypeScope;
use crate::source2::UtlVector;
#[derive(Pod)]
#[repr(C)]
pub struct SchemaSystem {
pad_0000: [u8; 0x190], // 0x0000
pub type_scopes: UtlVector<Pointer64<SchemaSystemTypeScope>>, // 0x0190
pad_01a0: [u8; 0x120], // 0x01A0
pub num_registrations: u32, // 0x02C0
pad_02c4: [u8; 0xAC], // 0x02C4
}

18
src/source2/schema_system/schema_system_type_scope.rs Normal file
View File

@ -0,0 +1,18 @@
use std::ffi::c_char;
use memflow::prelude::v1::*;
use super::{SchemaClassBinding, SchemaEnumBinding};
use crate::source2::UtlTsHash;
#[derive(Pod)]
#[repr(C)]
pub struct SchemaSystemTypeScope {
pad_0000: [u8; 0x8], // 0x0000
pub name: [c_char; 256], // 0x0008
pub global_scope: Pointer64<SchemaSystemTypeScope>, // 0x0108
pad_0110: [u8; 0x4B0], // 0x0110
pub class_bindings: UtlTsHash<Pointer64<SchemaClassBinding>>, // 0x05C0
pub enum_bindings: UtlTsHash<Pointer64<SchemaEnumBinding>>, // 0x2E50
}

97
src/source2/schema_system/schema_type.rs Normal file
View File

@ -0,0 +1,97 @@
use memflow::prelude::v1::*;
use super::{SchemaClassBinding, SchemaEnumBinding, SchemaSystemTypeScope};
#[repr(u8)]
pub enum SchemaAtomicCategory {
Basic = 0,
T,
CollectionOfT,
TF,
TT,
TTF,
I,
None,
}
#[repr(u8)]
pub enum SchemaTypeCategory {
BuiltIn = 0,
Ptr,
Bitfield,
FixedArray,
Atomic,
DeclaredClass,
DeclaredEnum,
None,
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaArrayT {
pub array_size: u32, // 0x0000
pad_0004: [u8; 0x4], // 0x0004
pub element: Pointer64<SchemaType>, // 0x0008
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicI {
pad_0000: [u8; 0x10], // 0x0000
pub value: u64, // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicT {
pub element: Pointer64<SchemaType>, // 0x0000
pad_0008: [u8; 0x8], // 0x0008
pub template: Pointer64<SchemaType>, // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTT {
pad_0000: [u8; 0x10], // 0x0000
pub templates: [Pointer64<SchemaType>; 2], // 0x0010
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTF {
pad_0000: [u8; 0x10], // 0x0000
pub template: Pointer64<SchemaType>, // 0x0010
pub size: i32, // 0x0018
}
#[derive(Clone, Copy)]
#[repr(C)]
pub struct SchemaAtomicTTF {
pad_0000: [u8; 0x10], // 0x0000
pub templates: [Pointer64<SchemaType>; 2], // 0x0010
pub size: i32, // 0x0020
}
#[repr(C)]
pub struct SchemaType {
pad_0000: [u8; 0x8], // 0x0000
pub name: Pointer64<ReprCString>, // 0x0008
pub type_scope: Pointer64<SchemaSystemTypeScope>, // 0x0010
pub type_category: SchemaTypeCategory, // 0x0018
pub atomic_category: SchemaAtomicCategory, // 0x0019
pub value: SchemaTypeUnion, // 0x0020
}
unsafe impl Pod for SchemaType {}
pub union SchemaTypeUnion {
pub schema_type: Pointer64<SchemaType>,
pub class_binding: Pointer64<SchemaClassBinding>,
pub enum_binding: Pointer64<SchemaEnumBinding>,
pub array: SchemaArrayT,
pub atomic: SchemaAtomicT,
pub atomic_tt: SchemaAtomicTT,
pub atomic_tf: SchemaAtomicTF,
pub atomic_ttf: SchemaAtomicTTF,
pub atomic_i: SchemaAtomicI,
}

3
src/source2/tier1/utl_memory.rs
View File

@ -10,13 +10,11 @@ pub struct UtlMemory<T> {
}
impl<T: Pod> UtlMemory<T> {
/// Returns the number of allocated elements.
#[inline]
pub fn count(&self) -> i32 {
self.alloc_count
}
/// Returns the element at the specified index.
pub fn element(&self, process: &mut IntoProcessInstanceArcBox<'_>, idx: usize) -> Result<T> {
if idx >= self.count() as usize {
return Err(Error::Other("index out of bounds"));
@ -25,7 +23,6 @@ impl<T: Pod> UtlMemory<T> {
self.mem.at(idx as _).read(process).map_err(Into::into)
}
/// Returns `true` if the memory was externally allocated.
#[inline]
pub fn is_externally_allocated(&self) -> bool {
self.grow_size < 0

3
src/source2/tier1/utl_memory_pool.rs
View File

@ -30,7 +30,7 @@ pub struct UtlMemoryPoolBase {
pub blocks_alloc: i32, // 0x000C
pub peak_alloc: i32, // 0x0010
pub alignment: u16, // 0x0014
pub num_blobs: u16, // 0x0016
pub blob_count: u16, // 0x0016
pub free_list_tail: Pointer64<Pointer64<FreeList>>, // 0x0018
pub free_list_head: Pointer64<FreeList>, // 0x0020
pad_0028: [u8; 0x44], // 0x0028
@ -40,7 +40,6 @@ pub struct UtlMemoryPoolBase {
}
impl UtlMemoryPoolBase {
/// Returns the total size of the memory pool.
#[inline]
pub fn size(&self) -> i32 {
self.total_size

4
src/source2/tier1/utl_ts_hash.rs
View File

@ -44,25 +44,21 @@ where
D: Pod + PointerExt,
K: Pod,
{
/// Returns the number of allocated blocks.
#[inline]
pub fn blocks_alloc(&self) -> i32 {
self.entry_mem.blocks_alloc
}
/// Returns the size of a block.
#[inline]
pub fn block_size(&self) -> i32 {
self.entry_mem.block_size
}
/// Returns the maximum number of allocated blocks.
#[inline]
pub fn peak_count(&self) -> i32 {
self.entry_mem.peak_alloc
}
/// Returns a list of allocated or unallocated elements.
pub fn elements(&self, process: &mut IntoProcessInstanceArcBox<'_>) -> Result<Vec<D>> {
let blocks_alloc = self.blocks_alloc() as usize;
let peak_alloc = self.peak_count() as usize;

2
src/source2/tier1/utl_vector.rs
View File

@ -9,13 +9,11 @@ pub struct UtlVector<T> {
}
impl<T: Pod> UtlVector<T> {
/// Returns the number of elements in the vector.
#[inline]
pub fn count(&self) -> i32 {
self.size
}
/// Returns the element at the specified index.
pub fn element(&self, process: &mut IntoProcessInstanceArcBox<'_>, idx: usize) -> Result<T> {
if idx >= self.count() as usize {
return Err(Error::Other("index out of bounds"));