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

some error cleanup

Browse source
This commit is contained in:
Robin Appelman 2019-10-05 13:12:25 +02:00
commit 8d6ef8e2fb
15 changed files with 311 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/demo/gameevent_gen.rs
View file

@ -1,5 +1,5 @@
use super::gamevent::{FromGameEventValue, FromRawGameEvent, GameEventValue, RawGameEvent};
use crate::{GameEventError, MalformedDemoError, Result};
use crate::{GameEventError, Result};
#[derive(Debug)]
pub struct ServerSpawnEvent {
pub hostname: String,
@ -7844,4 +7844,3 @@ impl GameEvent {
})
}
}

37
src/demo/gamevent.rs
View file

@ -1,6 +1,6 @@
use bitstream_reader::BitRead;
use crate::{MalformedDemoError, ParseError, Result};
use crate::{ParseError, Result};
pub use super::gameevent_gen::{GameEvent, GameEventType};
use crate::demo::message::gameevent::GameEventTypeId;
@ -89,12 +89,11 @@ impl FromGameEventValue for String {
match value {
Some(GameEventValue::String(val)) => Ok(val),
None => Ok(String::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::String,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -104,12 +103,11 @@ impl FromGameEventValue for f32 {
match value {
Some(GameEventValue::Float(val)) => Ok(val),
None => Ok(f32::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Float,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -119,12 +117,11 @@ impl FromGameEventValue for u32 {
match value {
Some(GameEventValue::Long(val)) => Ok(val),
None => Ok(u32::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Long,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -134,12 +131,11 @@ impl FromGameEventValue for u16 {
match value {
Some(GameEventValue::Short(val)) => Ok(val),
None => Ok(u16::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Short,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -149,12 +145,11 @@ impl FromGameEventValue for u8 {
match value {
Some(GameEventValue::Byte(val)) => Ok(val),
None => Ok(u8::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Byte,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -164,12 +159,11 @@ impl FromGameEventValue for bool {
match value {
Some(GameEventValue::Boolean(val)) => Ok(val),
None => Ok(bool::default()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Boolean,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}
@ -178,12 +172,11 @@ impl FromGameEventValue for () {
fn from_value(value: Option<GameEventValue>, name: &'static str) -> Result<Self> {
match value {
Some(GameEventValue::Local) | None => Ok(()),
Some(value) => Err(MalformedDemoError::InvalidGameEvent {
Some(value) => Err(ParseError::InvalidGameEvent {
expected_type: GameEventValueType::Local,
name,
found_type: value.get_type(),
}
.into()),
}),
}
}
}

10
src/demo/message/gameevent.rs
View file

@ -9,9 +9,7 @@ use crate::demo::gamevent::{
RawGameEvent,
};
use crate::demo::parser::ParseBitSkip;
use crate::{
GameEventError, MalformedDemoError, Parse, ParseError, ParserState, ReadResult, Result, Stream,
};
use crate::{GameEventError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<GameEventValue> {
Ok(match definition.kind {
@ -48,11 +46,7 @@ impl Parse for GameEventMessage {
values,
}
}
None => {
return Err(
MalformedDemoError::MalformedGameEvent(GameEventError::UnknownType).into(),
)
}
None => return Err(ParseError::MalformedGameEvent(GameEventError::UnknownType)),
};
let event = GameEvent::from_raw_event(raw_event)?;
Ok(GameEventMessage { event })

4
src/demo/message/mod.rs
View file

@ -15,7 +15,7 @@ use crate::demo::message::tempentities::*;
use crate::demo::message::usermessage::*;
use crate::demo::message::voice::*;
use crate::demo::parser::ParseBitSkip;
use crate::{MalformedDemoError, Parse, ParseError, ParserState, Result, Stream};
use crate::{Parse, ParseError, ParserState, Result, Stream};
pub mod bspdecal;
pub mod classinfo;
@ -65,7 +65,7 @@ impl Parse for MessageType {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let raw = stream.read_int(6)?;
let prop_type: Option<MessageType> = MessageType::from_u8(raw);
prop_type.ok_or(MalformedDemoError::InvalidMessageType(raw).into())
prop_type.ok_or(ParseError::InvalidMessageType(raw))
}
}

10
src/demo/message/packetentities.rs
View file

@ -6,7 +6,7 @@ use crate::demo::message::stringtable::{log_base2, read_var_int};
use crate::demo::packet::datatable::{ClassId, SendTable, SendTableName, ServerClass};
use crate::demo::parser::ParseBitSkip;
use crate::demo::sendprop::{SendProp, SendPropDefinition, SendPropValue};
use crate::{MalformedDemoError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use parse_display::{Display, FromStr};
use std::collections::HashMap;
use std::fmt;
@ -111,7 +111,7 @@ fn get_send_table(state: &ParserState, class: ClassId) -> Result<&SendTable> {
state
.send_tables
.get(usize::from(class))
.ok_or_else(|| MalformedDemoError::UnknownServerClass(class).into())
.ok_or_else(|| ParseError::UnknownServerClass(class))
}
fn get_entity_for_update(
@ -122,7 +122,7 @@ fn get_entity_for_update(
let class_id = *state
.entity_classes
.get(&entity_index)
.ok_or_else(|| MalformedDemoError::UnknownEntity(entity_index))?;
.ok_or_else(|| ParseError::UnknownEntity(entity_index))?;
Ok(PacketEntity {
server_class: class_id,
@ -207,7 +207,7 @@ impl PacketEntitiesMessage {
let send_table = state
.send_tables
.get(usize::from(class_index))
.ok_or_else(|| MalformedDemoError::UnknownServerClass(class_index))?;
.ok_or_else(|| ParseError::UnknownServerClass(class_index))?;
let props = match state.instance_baselines[baseline_index].get(&entity_index) {
Some(baseline) => baseline.clone(),
@ -250,7 +250,7 @@ impl PacketEntitiesMessage {
});
}
None => {
return Err(ParseError::from(MalformedDemoError::PropIndexOutOfBounds {
return Err(ParseError::from(ParseError::PropIndexOutOfBounds {
index,
prop_count: send_table.flattened_props.len(),
}))

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

@ -6,7 +6,7 @@ use crate::demo::packet::stringtable::{
ExtraData, FixedUserDataSize, StringTable, StringTableEntry,
};
use crate::demo::parser::ParseBitSkip;
use crate::{MalformedDemoError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
#[derive(Debug)]
pub struct CreateStringTableMessage {
@ -122,7 +122,7 @@ impl Parse for UpdateStringTableMessage {
let entries = match state.string_tables.get(table_id as usize) {
Some(table) => parse_string_table_update(&mut data, table, changed),
None => return Err(MalformedDemoError::StringTableNotFound(table_id).into()),
None => return Err(ParseError::StringTableNotFound(table_id).into()),
}?;
Ok(UpdateStringTableMessage { table_id, entries })

4
src/demo/packet/datatable.rs
View file

@ -4,7 +4,7 @@ use crate::demo::parser::MalformedSendPropDefinitionError;
use crate::demo::sendprop::{
SendPropDefinition, SendPropDefinitionIndex, SendPropFlag, SendPropName, SendPropType,
};
use crate::{MalformedDemoError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use parse_display::{Display, FromStr};
use serde::{Deserialize, Serialize};
use std::borrow::Borrow;
@ -220,7 +220,7 @@ impl Parse for DataTablePacket {
let server_classes = packet_data.read_sized(server_class_count)?;
if packet_data.bits_left() > 7 {
Err(MalformedDemoError::DataRemaining(packet_data.bits_left()).into())
Err(ParseError::DataRemaining(packet_data.bits_left()))
} else {
Ok(DataTablePacket {
tick,

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

@ -3,7 +3,7 @@ use std::fmt;
use bitstream_reader::{BitRead, LittleEndian};
use crate::demo::message::stringtable::StringTableMeta;
use crate::{MalformedDemoError, Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
#[derive(BitRead, Clone, Copy, Debug)]
pub struct FixedUserDataSize {
@ -125,7 +125,7 @@ impl Parse for StringTablePacket {
let tables = packet_data.read_sized(count)?;
if packet_data.bits_left() > 7 {
Err(MalformedDemoError::DataRemaining(packet_data.bits_left()).into())
Err(ParseError::DataRemaining(packet_data.bits_left()))
} else {
Ok(StringTablePacket { tick, tables })
}

111
src/demo/parser/error.rs Normal file
View file

@ -0,0 +1,111 @@
use crate::demo::gamevent::GameEventValueType;
use crate::demo::message::packetentities::EntityId;
use crate::demo::packet::datatable::{ClassId, SendTableName};
use bitstream_reader::{FromUtf8Error, ReadError};
use err_derive::Error;
/// Errors that can occur during parsing
#[derive(Debug, Error)]
pub enum ParseError {
#[error(display = "Error while reading bits from stream: {}", _0)]
ReadError(#[error(source, no_from)] ReadError),
#[error(display = "Malformed utf8 while reading string")]
MalformedUTF8(#[error(source)] FromUtf8Error),
#[error(display = "Unexpected type of compressed data: {}", _0)]
UnexpectedCompressionType(String),
#[error(
display = "Error while decompressing SNAP compressed string table: {}",
_0
)]
SnapError(#[error(source)] snap::Error),
#[error(
display = "Unexpected size after decompressing SNAP data, got {} bytes, expected {} bytes",
size,
expected
)]
UnexpectedDecompressedSize {
/// Expected decompressed size
expected: u32,
/// Actual decompressed size
size: u32,
},
#[error(display = "Malformed demo file: {}", _0)]
InvalidDemo(&'static str),
#[error(display = "Packet identifier is invalid: {}", _0)]
InvalidPacketType(u8),
#[error(display = "Message identifier is invalid: {}", _0)]
InvalidMessageType(u8),
#[error(display = "Invalid SendProp type: {}", _0)]
InvalidSendPropType(u8),
#[error(display = "Invalid SendProp: {}", _0)]
InvalidSendProp(#[error(source)] MalformedSendPropDefinitionError),
#[error(
display = "Unexpected amount of data left after parsing an object, {} bits remaining",
_0
)]
DataRemaining(usize),
#[error(display = "String table with index {} not found", _0)]
StringTableNotFound(u8),
#[error(display = "A malformed game event was read")]
MalformedGameEvent(#[error(source)] GameEventError),
#[error(
display = "A read game event doesn't contain the expected values, expected type {} for {} event, got type {}",
expected_type,
name,
found_type
)]
InvalidGameEvent {
expected_type: GameEventValueType,
name: &'static str,
found_type: GameEventValueType,
},
#[error(display = "An entity with an unknown server class({}) was read", _0)]
UnknownServerClass(ClassId),
#[error(display = "Unknown send table: {}", _0)]
UnknownSendTable(SendTableName),
#[error(
display = "Property index out of bounds, got {} but only {} props exist",
_0,
_1
)]
PropIndexOutOfBounds { index: i32, prop_count: usize },
#[error(display = "An attempt was made to update an unknown entity: {}", _0)]
UnknownEntity(EntityId),
}
#[derive(Debug, Error)]
pub enum MalformedSendPropDefinitionError {
#[error(display = "Float property without defined size")]
UnsizedFloat,
#[error(display = "Array property without defined size")]
UnsizedArray,
#[error(display = "Array property without defined inner type")]
UntypedArray,
#[error(display = "Property used that can't be read")]
InvalidPropType,
#[error(display = "Array contents can't have the 'ChangesOften' flag")]
ArrayChangesOften,
#[error(display = "SendProp value out of range")]
OutOfRange,
}
#[derive(Debug, Error)]
pub enum GameEventError {
#[error(display = "Incorrect number of values")]
IncorrectValueCount,
#[error(display = "Event with 'none' value")]
NoneValue,
#[error(display = "Unknown type")]
UnknownType,
}
impl From<ReadError> for ParseError {
fn from(err: ReadError) -> ParseError {
match err {
ReadError::Utf8Error(utf8_error) => ParseError::MalformedUTF8(utf8_error),
_ => ParseError::ReadError(err),
}
}
}
pub type Result<T> = std::result::Result<T, ParseError>;

138
src/demo/parser/mod.rs
View file

@ -14,146 +14,12 @@ use crate::Stream;
use err_derive::Error;
mod analyser;
mod error;
mod handler;
mod messagetypeanalyser;
mod state;
/// Errors that can occur during parsing
#[derive(Debug, Error)]
pub enum ParseError {
#[error(display = "Error while reading bits from stream: {}", _0)]
ReadError(#[error(cause)] ReadError),
#[error(display = "Malformed utf8 while reading string")]
MalformedUTF8(#[error(cause)] FromUtf8Error),
#[error(display = "Malformed demo file: {}", _0)]
MalformedDemo(#[error(cause)] MalformedDemoError),
#[error(display = "Unexpected type of compressed data: {}", _0)]
UnexpectedCompressionType(String),
#[error(
display = "Error while decompressing SNAP compressed string table: {}",
_0
)]
SnapError(#[error(cause)] snap::Error),
#[error(
display = "Unexpected size after decompressing SNAP data, got {} bytes, expected {} bytes",
size,
expected
)]
UnexpectedDecompressedSize {
/// Expected decompressed size
expected: u32,
/// Actual decompressed size
size: u32,
},
#[error(display = "Malformed demo file: {}", _0)]
InvalidDemo(&'static str),
}
/// Malformed demo file
#[derive(Debug, Error)]
pub enum MalformedDemoError {
#[error(display = "Packet identifier is invalid: {}", _0)]
InvalidPacketType(u8),
#[error(display = "Message identifier is invalid: {}", _0)]
InvalidMessageType(u8),
#[error(display = "Invalid SendProp type: {}", _0)]
InvalidSendPropType(u8),
#[error(display = "Invalid SendProp: {}", _0)]
InvalidSendProp(MalformedSendPropDefinitionError),
#[error(
display = "Unexpected amount of data left after parsing an object, {} bits remaining",
_0
)]
DataRemaining(usize),
#[error(display = "String table with index {} not found", _0)]
StringTableNotFound(u8),
#[error(display = "A malformed game event was read")]
MalformedGameEvent(#[error(cause)] GameEventError),
#[error(
display = "A read game event doesn't contain the expected values, expected type {} for {} event, got type {}",
expected_type,
name,
found_type
)]
InvalidGameEvent {
expected_type: GameEventValueType,
name: &'static str,
found_type: GameEventValueType,
},
#[error(display = "An entity with an unknown server class({}) was read", _0)]
UnknownServerClass(ClassId),
#[error(display = "Unknown send table: {}", _0)]
UnknownSendTable(SendTableName),
#[error(
display = "Property index out of bounds, got {} but only {} props exist",
_0,
_1
)]
PropIndexOutOfBounds { index: i32, prop_count: usize },
#[error(display = "An attempt was made to update an unknown entity: {}", _0)]
UnknownEntity(EntityId),
}
#[derive(Debug, Error)]
pub enum MalformedSendPropDefinitionError {
#[error(display = "Float property without defined size")]
UnsizedFloat,
#[error(display = "Array property without defined size")]
UnsizedArray,
#[error(display = "Array property without defined inner type")]
UntypedArray,
#[error(display = "Property used that can't be read")]
InvalidPropType,
#[error(display = "Array contents can't have the 'ChangesOften' flag")]
ArrayChangesOften,
#[error(display = "SendProp value out of range")]
OutOfRange,
}
#[derive(Debug, Error)]
pub enum GameEventError {
#[error(display = "Incorrect number of values")]
IncorrectValueCount,
#[error(display = "Event with 'none' value")]
NoneValue,
#[error(display = "Unknown type")]
UnknownType,
}
impl From<ReadError> for ParseError {
fn from(err: ReadError) -> ParseError {
match err {
ReadError::Utf8Error(utf8_error) => ParseError::MalformedUTF8(utf8_error),
_ => ParseError::ReadError(err),
}
}
}
impl From<snap::Error> for ParseError {
fn from(err: snap::Error) -> ParseError {
ParseError::SnapError(err)
}
}
impl From<MalformedDemoError> for ParseError {
fn from(err: MalformedDemoError) -> ParseError {
ParseError::MalformedDemo(err)
}
}
impl From<MalformedSendPropDefinitionError> for ParseError {
fn from(err: MalformedSendPropDefinitionError) -> ParseError {
ParseError::MalformedDemo(MalformedDemoError::InvalidSendProp(err))
}
}
impl From<GameEventError> for ParseError {
fn from(err: GameEventError) -> ParseError {
ParseError::MalformedDemo(MalformedDemoError::MalformedGameEvent(err))
}
}
pub type Result<T> = std::result::Result<T, ParseError>;
pub use self::error::*;
pub trait Parse: Sized {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self>;

2
src/demo/sendprop.rs
View file

@ -3,7 +3,7 @@ use enumflags2::BitFlags;
use enumflags2_derive::EnumFlags;
use serde::{Deserialize, Serialize};
use crate::{MalformedDemoError, Parse, ParseError, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ReadResult, Result, Stream};
use super::packet::datatable::ParseSendTable;
use super::vector::{Vector, VectorXY};

4
src/lib.rs
View file

@ -7,8 +7,8 @@ pub use bitstream_reader::Result as ReadResult;
pub use crate::demo::{
message::MessageType,
parser::{
DemoParser, GameEventError, MalformedDemoError, MatchState, MessageTypeAnalyser, Parse,
ParseError, ParserState, Result,
DemoParser, GameEventError, MatchState, MessageTypeAnalyser, Parse, ParseError,
ParserState, Result,
},
Demo, Stream,
};