rune_parser/types/
arrays.rs1use 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)]
11pub enum ArraySize {
13 Integer(u64, NumeralSystem),
15 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}