Skip to main content

rune_parser/post_processing/
process_defines.rs

1use 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    // Create a list of all user defines found across all files
17    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    // Check for duplicates
28    // —————————————————————
29
30    // Check for multiple definitions of the same define. Only necessary if more than one item in the list
31    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    // Check for multiple definitions of the same redefine. Only necessary if more than one item in the list
43    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    // Process files
55    // ——————————————
56
57    for file in definitions {
58        // Find all definitions in the file, and check to see if there is any redefinition for it
59        for define_definition in &mut file.definitions.defines {
60            for i in 0..redefines_list.len() {
61                // Check to see if names match
62                if define_definition.name == redefines_list[i].name {
63                    // Add redefinition to the define
64                    define_definition.redefinition = Some(redefines_list[i].clone());
65
66                    // Remove from redefines_list so we can check for orphan redefinitions after processing al files
67                    redefines_list.swap_remove(i);
68                }
69            }
70        }
71
72        // So far, array sizes are the only valid place to use define values inside Rune itself
73        // Check all message fields for array members, and check if their size is defined by a UserDefinition
74        for message_definition in &mut file.definitions.messages {
75            // Check all message members
76            for field in &mut message_definition.fields {
77                // Check if field type is array
78                if let FieldType::Array(array) = &mut field.data_type {
79                    // Check to see if the array size is a user defined value
80                    if let ArraySize::UserDefinition(definition) = &mut array.element_count {
81                        // Find define value
82                        for user_define in &defines_list {
83                            // Match with identifier string
84                            if user_define.name == definition.name {
85                                // Check for redefinition
86                                let define_value: &DefineValue = match &user_define.redefinition {
87                                    None => &user_define.value,
88                                    Some(redefine) => &redefine.value
89                                };
90
91                                // Parse the value. Only integer values are valid
92                                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}