Skip to main content

rune_parser/types/
arrays.rs

1use std::fmt::{Debug, Display, Formatter};
2
3use crate::{
4    output::*,
5    scanner::{NumeralSystem, NumericLiteral},
6    types::{DefineDefinition, DefineValue, Primitive, UserDefinitionLink},
7    RuneParserError
8};
9
10#[derive(Clone, Debug)]
11/// Size of an array, storing how the user described the value
12pub enum ArraySize {
13    /// Size described by a integer number. Can be written in several numeric systems
14    Integer(u64, NumeralSystem),
15    /// Size described by value defined elsewhere by the user
16    UserDefinition(DefineDefinition)
17}
18
19#[derive(Clone, Debug)]
20pub enum ArrayType {
21    Primitive(Primitive),
22    UserDefined(String, UserDefinitionLink)
23}
24
25#[derive(Clone, Debug)]
26pub struct Array {
27    pub data_type:     ArrayType,
28    pub element_count: ArraySize
29}
30
31impl ArraySize {
32    pub fn last_index_string(&self) -> String {
33        match self {
34            ArraySize::Integer(value, numeral_system) => match numeral_system {
35                NumeralSystem::Binary => format!("0b{0:b}", value - 1),
36                NumeralSystem::Decimal => (value - 1).to_string(),
37                NumeralSystem::Hexadecimal => format!("0x{0:02X}", value - 1)
38            },
39            ArraySize::UserDefinition(definition) => {
40                let value = match &definition.redefinition {
41                    None => &definition.value,
42                    Some(redefinition) => &redefinition.value
43                };
44
45                match value {
46                    DefineValue::NoValue => format!("{0} - 1", definition.name),
47                    DefineValue::NumericLiteral(literal) => match literal {
48                        NumericLiteral::PositiveInteger(value, numeral_system) => match numeral_system {
49                            NumeralSystem::Binary => format!("0b{0:b}", value - 1),
50                            NumeralSystem::Decimal => format!("{0}", value - 1),
51                            NumeralSystem::Hexadecimal => format!("0x{0:02X}", value - 1)
52                        },
53
54                        _ => unreachable!("Only positive integer numbers can be indexes")
55                    }
56                }
57            }
58        }
59    }
60
61    pub fn value(&self) -> Result<u64, RuneParserError> {
62        match self {
63            ArraySize::Integer(value, _) => Ok(*value),
64            ArraySize::UserDefinition(definition) => {
65                let define_value = match &definition.redefinition {
66                    None => &definition.value,
67                    Some(redefinition) => &redefinition.value
68                };
69
70                match define_value {
71                    DefineValue::NumericLiteral(NumericLiteral::PositiveInteger(value, _)) => Ok(*value),
72                    _ => Err(RuneParserError::InvalidArraySize)
73                }
74            }
75        }
76    }
77}
78
79impl Display for ArraySize {
80    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
81        match self {
82            ArraySize::Integer(value, numeral_system) => match numeral_system {
83                NumeralSystem::Binary => write!(formatter, "0b{0:b}", value),
84                NumeralSystem::Decimal => write!(formatter, "{0}", value),
85                NumeralSystem::Hexadecimal => write!(formatter, "0x{0:02X}", value)
86            },
87
88            ArraySize::UserDefinition(value) => write!(formatter, "{0}", value.name)
89        }
90    }
91}
92
93impl PartialEq for ArraySize {
94    fn eq(&self, other: &ArraySize) -> bool {
95        match self {
96            ArraySize::Integer(value, _) => match other {
97                ArraySize::Integer(other_value, _) => value == other_value,
98                _ => false
99            },
100            ArraySize::UserDefinition(definition) => match other {
101                ArraySize::UserDefinition(other_definition) => definition.name == other_definition.name,
102                _ => false
103            }
104        }
105    }
106}
107
108impl ArrayType {
109    pub fn size(&self) -> Result<u64, RuneParserError> {
110        match self {
111            ArrayType::Primitive(primitive) => Ok(primitive.encoded_max_data_size()),
112            ArrayType::UserDefined(_, definition_link) => match &definition_link {
113                UserDefinitionLink::NoLink => {
114                    error!("User defined array type had no link!");
115                    Err(RuneParserError::UndefinedIdentifier)
116                },
117                UserDefinitionLink::EnumLink(enum_link) => Ok(enum_link.backing_type.encoded_max_data_size()),
118                UserDefinitionLink::BitfieldLink(bitfield_link) => Ok(bitfield_link.backing_type.encoded_max_data_size()),
119                UserDefinitionLink::MessageLink(_) => {
120                    error!("Cannot have message array");
121                    Err(RuneParserError::InvalidArrayType)
122                },
123                UserDefinitionLink::StructLink(struct_link) => Ok(struct_link.flat_size()?)
124            }
125        }
126    }
127}
128
129impl PartialEq for ArrayType {
130    fn eq(&self, other: &ArrayType) -> bool {
131        match self {
132            ArrayType::Primitive(primitive) => match other {
133                ArrayType::Primitive(other_primitive) => primitive == other_primitive,
134                _ => false
135            },
136            ArrayType::UserDefined(definition, _) => match other {
137                ArrayType::UserDefined(other_definition, _) => definition == other_definition,
138                _ => false
139            }
140        }
141    }
142}
143
144impl PartialEq for Array {
145    fn eq(&self, other: &Array) -> bool {
146        (self.data_type == other.data_type) && (self.element_count == other.element_count)
147    }
148}
149
150impl Array {
151    pub fn byte_size(&self) -> Result<u64, RuneParserError> {
152        Ok(self.data_type.size()? * self.element_count.value()?)
153    }
154}