demostf/parser
1
0
Fork 0
mirror of https://codeberg.org/demostf/parser.git synced 2026-06-03 10:14:06 +02:00
Code Issues Releases Wiki Activity

remove the need to keep the full stringtables in state

Browse source
This commit is contained in:
Robin Appelman 2019-03-06 17:15:42 +01:00
commit 3783eb5d9e
5 changed files with 54 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/demo/message/stringtable.rs
View file

@ -4,10 +4,10 @@ use bitstream_reader::{BitBuffer, BitRead, BitReadSized, BitStream, LittleEndian
use num_traits::{PrimInt, Unsigned};
use snap::Decoder;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::demo::packet::stringtable::{
ExtraData, FixedUserdataSize, StringTable, StringTableEntry,
};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
#[derive(Debug)]
pub struct CreateStringTableMessage {
@ -92,7 +92,7 @@ impl Parse for CreateStringTableMessage {
#[derive(Debug)]
pub struct UpdateStringTableMessage {
pub entries: HashMap<u16, StringTableEntry>,
pub entries: Vec<(u16, StringTableEntry)>,
pub table_id: u8,
}
@ -106,11 +106,10 @@ impl Parse for UpdateStringTableMessage {
let mut data = stream.read_bits(len)?;
let entries = match state.string_tables.get(table_id as usize) {
Some(table) => parse_string_table_sparse_entries(
Some(table) => parse_string_table_update(
&mut data,
&table.get_table_meta(),
table,
changed,
&table.entries,
),
None => return Err(ParseError::StringTableNotFound(table_id)),
}?;
@ -119,17 +118,16 @@ impl Parse for UpdateStringTableMessage {
}
}
fn parse_string_table_sparse_entries(
fn parse_string_table_update(
stream: &mut Stream,
table_meta: &StringTableMeta,
entry_count: u16,
existing_entries: &Vec<StringTableEntry>,
) -> ReadResult<HashMap<u16, StringTableEntry>> {
) -> ReadResult<Vec<(u16, StringTableEntry)>> {
let entry_bits = log_base2(table_meta.max_entries);
let mut entries = HashMap::with_capacity(entry_count as usize);
let mut entries = Vec::with_capacity(entry_count as usize);
let mut last_entry: i16 = -1;
let mut history: Vec<String> = Vec::new();
let mut history: Vec<Option<String>> = Vec::new();
for i in 0..entry_count {
let index = if stream.read()? {
@ -143,13 +141,12 @@ fn parse_string_table_sparse_entries(
let entry = read_table_entry(
stream,
table_meta,
&history,
existing_entries.get(index as usize),
&history
)?;
// optimize: any way to get rid of the clone here?
// `entries` always outlives `history` without reallocation
let text = entry.text.clone();
entries.insert(index, entry);
entries.push((index, entry));
// not 100% sure we should be pushing front here, and not appending
history.push(text);
@ -169,14 +166,14 @@ fn parse_string_table_list(
let entry_bits = log_base2(table_meta.max_entries);
let mut entries = Vec::with_capacity(entry_count as usize);
let mut history: Vec<String> = Vec::new();
let mut history: Vec<Option<String>> = Vec::new();
for i in 0..entry_count {
if !stream.read::<bool>()? {
panic!("there should be no holes when reading CreateStringTable message");
};
let entry = read_table_entry(stream, table_meta, &history, None)?;
let entry = read_table_entry(stream, table_meta, &history)?;
// optimize: any way to get rid of the clone here?
// `entries` always outlives `history` without reallocation
let text = entry.text.clone();
@ -195,10 +192,9 @@ fn parse_string_table_list(
fn read_table_entry(
stream: &mut Stream,
table_meta: &StringTableMeta,
history: &Vec<String>,
existing_entry: Option<&StringTableEntry>,
history: &Vec<Option<String>>,
) -> ReadResult<StringTableEntry> {
let value = if stream.read()? {
let text = if stream.read()? {
// set value
if stream.read()? {
// reuse from history
@ -206,7 +202,7 @@ fn read_table_entry(
let bytes_to_copy: u32 = stream.read_sized(5)?;
let rest_of_string: String = stream.read()?;
Some(match history.get(index as usize) {
Some(match history.get(index as usize).and_then(|h| h.as_ref()) {
Some(text) => String::from_utf8({
text.bytes()
.take(bytes_to_copy as usize)
@ -222,7 +218,7 @@ fn read_table_entry(
None
};
let user_data = if stream.read()? {
let extra_data = if stream.read()? {
Some(match table_meta.fixed_userdata_size {
Some(size) => stream.read_bits(size.bits as usize)?,
None => {
@ -233,21 +229,11 @@ fn read_table_entry(
} else {
None
}
.map(ExtraData::new);
.map(ExtraData::new);
Ok(match existing_entry {
Some(existing_entry) => {
let new_user_data = user_data.or_else(|| existing_entry.extra_data.clone());
let new_value = value.unwrap_or_else(|| existing_entry.text.clone());
StringTableEntry {
text: new_value,
extra_data: new_user_data,
}
}
None => StringTableEntry {
text: value.unwrap_or_default(),
extra_data: user_data,
},
Ok(StringTableEntry {
text,
extra_data,
})
}

24
src/demo/packet/stringtable.rs
View file

@ -72,21 +72,35 @@ impl ExtraData {
}
}
#[derive(BitRead, Clone, Default)]
#[endianness = "LittleEndian"]
#[derive(Clone, Default)]
pub struct StringTableEntry {
pub text: String,
pub text: Option<String>,
pub extra_data: Option<ExtraData>,
}
impl StringTableEntry {
pub fn text(&self) -> &str {
self.text.as_ref().map(|s| s.as_str()).unwrap_or("")
}
}
impl BitRead<LittleEndian> for StringTableEntry {
fn read(stream: &mut Stream) -> ReadResult<Self> {
Ok(StringTableEntry {
text: Some(stream.read()?),
extra_data: stream.read()?
})
}
}
impl fmt::Debug for StringTableEntry {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match &self.extra_data {
None => write!(f, "StringTableEntry {{ text: \"{}\" }}", self.text),
None => write!(f, "StringTableEntry {{ text: \"{}\" }}", self.text()),
Some(extra_data) => write!(
f,
"StringTableEntry{{ text: \"{}\" extra_data: {} bytes }}",
self.text, extra_data.byte_len
self.text(), extra_data.byte_len
),
}
}

6
src/demo/parser/analyser.rs
View file

@ -200,10 +200,10 @@ impl StringTableEntryHandler for Analyser {
fn handle_string_entry(&mut self, table: &String, index: usize, entry: &StringTableEntry) {
match table.as_str() {
"userinfo" => {
match &entry.extra_data {
Some(data) => {
match (&entry.text, &entry.extra_data) {
(Some(text), Some(data)) => {
if data.byte_len > 32 {
let _ = self.parse_user_info(&entry.text, data.data.clone());
let _ = self.parse_user_info(text, data.data.clone());
}
}
_ => {} //unreachable!("no userdata {}, {}", table, &entry.text)

17
src/demo/parser/handler.rs
View file

@ -68,20 +68,19 @@ impl DemoHandler {
fn handle_string_table(&mut self, table: StringTable) {
self.string_table_names.push(table.name.clone());
for (entry_index, entry) in table.entries.iter().enumerate() {
self.state_handler.handle_string_table_meta(table.get_table_meta());
for (entry_index, entry) in table.entries.into_iter().enumerate() {
self.handle_string_entry(&table.name, entry_index, entry);
}
self.state_handler.handle_string_table(table);
}
fn handle_table_update(&mut self, table_id: u8, entries: HashMap<u16, StringTableEntry>) {
fn handle_table_update(&mut self, table_id: u8, entries: Vec<(u16, StringTableEntry)>) {
let table_name = self.string_table_names.get(table_id as usize);
match table_name {
Some(table_name) => {
let table_name = table_name.clone();
for (index, entry) in &entries {
self.handle_string_entry(&table_name, *index as usize, entry);
for (index, entry) in entries {
self.handle_string_entry(&table_name, index as usize, entry);
}
}
_ => unreachable!("trying to update non existing table"),
@ -93,10 +92,10 @@ impl DemoHandler {
.handle_data_table(send_tables, server_classes);
}
fn handle_string_entry(&mut self, table: &String, index: usize, entries: &StringTableEntry) {
fn handle_string_entry(&mut self, table: &String, index: usize, entries: StringTableEntry) {
self.state_handler
.handle_string_entry(table, index, entries);
self.analyser.handle_string_entry(table, index, entries);
.handle_string_entry(table, index, &entries);
self.analyser.handle_string_entry(table, index, &entries);
}
fn handle_message(&mut self, message: Message) {

27
src/demo/parser/state.rs
View file

@ -21,7 +21,7 @@ pub struct ParserState {
pub version: u16,
pub static_baselines: HashMap<u32, StaticBaseline>,
pub event_definitions: HashMap<GameEventTypeId, GameEventDefinition>,
pub string_tables: Vec<StringTable>,
pub string_tables: Vec<StringTableMeta>,
pub entity_classes: HashMap<EntityId, ServerClass>,
pub send_tables: HashMap<String, SendTable>,
pub server_classes: Vec<ServerClass>,
@ -62,30 +62,9 @@ impl ParserState {
self.server_classes = server_classes
}
pub fn handle_string_table(&mut self, table: StringTable) {
pub fn handle_string_table_meta(&mut self, table: StringTableMeta) {
self.string_tables.push(table);
}
pub fn handle_string_table_update(
&mut self,
table_id: u8,
entries: HashMap<u16, StringTableEntry>,
) {
match self.string_tables.get_mut(table_id as usize) {
Some(table) => {
for (index, entry) in entries {
let index = index as usize;
if index > table.entries.len() {
table.entries.resize(index, StringTableEntry::default())
}
unsafe {
replace(table.entries.get_unchecked_mut(index), entry);
}
}
}
_ => unreachable!(),
}
}
}
impl MessageHandler for ParserState {
@ -118,7 +97,7 @@ impl StringTableEntryHandler for ParserState {
fn handle_string_entry(&mut self, table: &String, index: usize, entry: &StringTableEntry) {
match table.as_str() {
"instancebaseline" => match &entry.extra_data {
Some(extra) => match entry.text.parse::<u32>() {
Some(extra) => match entry.text().parse::<u32>() {
Ok(class_id) => {
let baseline = StaticBaseline::new(class_id, extra.data.clone());
self.static_baselines.insert(class_id, baseline);