rune_parser/post_processing/
process_defines.rs1use crate::{
2 output::*,
3 scanner::NumericLiteral,
4 types::{DefineDefinition, DefineValue, FieldType, RedefineDefinition},
5 ArraySize, RuneFileDescription, RuneParserError
6};
7
8const VEC_SIZE: usize = 0x40;
9
10pub fn parse_define_statements(definitions: &mut Vec<RuneFileDescription>) -> Result<(), RuneParserError> {
11 info!("Parsing define statements");
12
13 let mut defines_list: Vec<DefineDefinition> = Vec::with_capacity(VEC_SIZE);
14 let mut redefines_list: Vec<RedefineDefinition> = Vec::with_capacity(VEC_SIZE);
15
16 for file in definitions.clone() {
18 for definition in &file.definitions.defines {
19 defines_list.push(definition.clone());
20 }
21
22 for redefinition in &file.definitions.redefines {
23 redefines_list.push(redefinition.clone());
24 }
25 }
26
27 if defines_list.len() > 1 {
32 for i in 0..(defines_list.len() - 1) {
33 for definition in &defines_list[(i + 1)..] {
34 if defines_list[i].name == definition.name {
35 error!("Found duplicate definition of {0}. Aborting parsing.", defines_list[i].name);
36 return Err(RuneParserError::MultipleDefinitions);
37 }
38 }
39 }
40 }
41
42 if redefines_list.len() > 1 {
44 for i in 0..(redefines_list.len() - 1) {
45 for redefinition in &redefines_list[(i + 1)..] {
46 if redefines_list[i].name == redefinition.name {
47 error!("Multiple redefinitions of {0}! Only a single redefinition of a define is supported.", redefines_list[i].name);
48 return Err(RuneParserError::MultipleRedefinitions);
49 }
50 }
51 }
52 }
53
54 for file in definitions {
58 for define_definition in &mut file.definitions.defines {
60 for i in 0..redefines_list.len() {
61 if define_definition.name == redefines_list[i].name {
63 define_definition.redefinition = Some(redefines_list[i].clone());
65
66 redefines_list.swap_remove(i);
68 }
69 }
70 }
71
72 for message_definition in &mut file.definitions.messages {
75 for field in &mut message_definition.fields {
77 if let FieldType::Array(array) = &mut field.data_type {
79 if let ArraySize::UserDefinition(definition) = &mut array.element_count {
81 for user_define in &defines_list {
83 if user_define.name == definition.name {
85 let define_value: &DefineValue = match &user_define.redefinition {
87 None => &user_define.value,
88 Some(redefine) => &redefine.value
89 };
90
91 match define_value {
93 DefineValue::NumericLiteral(value) => match value {
94 NumericLiteral::PositiveInteger(_, _) => definition.value = DefineValue::NumericLiteral(value.clone()),
95 _ => {
96 error!("Could not parse {0} into a valid positive integer value!", definition.name);
97 return Err(RuneParserError::InvalidNumericValue);
98 }
99 },
100 _ => {
101 error!("Could not parse {0} into a valid positive integer value!", definition.name);
102 return Err(RuneParserError::InvalidNumericValue);
103 }
104 }
105 }
106 }
107 }
108 }
109 }
110 }
111 }
112
113 for orphan_redefinition in redefines_list {
114 warning!("Define statement for redefinition {0} not found, so it will thus be ignored and do nothing.", orphan_redefinition.name);
115 }
116
117 Ok(())
118}