1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
use crate::*;
pub struct ConstantExpression {
pub tokens: Vec<ConstantExpressionToken>,
}
impl ConstantExpression {
pub fn from_str(string: &str, tokeniser: &Tokeniser) -> Self {
parse_constant_expression(string, tokeniser)
}
}
pub struct ConstantExpressionToken {
pub source: SourceSpan,
pub variant: ConstantExpressionTokenVariant,
}
pub enum ConstantExpressionTokenVariant {
SymbolReference(String),
IntegerLiteral(usize),
Operator(Operator),
Error(ConstantExpressionParseError),
}
pub enum Operator {
Equal,
NotEqual,
LessThan,
GreaterThan,
Add,
Subtract,
LeftShift,
RightShift,
And,
Or,
Xor,
Not,
}
pub enum ConstantExpressionParseError {
InvalidHexadecimalLiteral(String),
}
impl ConstantExpression {
pub fn evaluate(&self, environment: &Environment) -> Result<usize, ConstantExpressionEvaluationError> {
use ConstantExpressionTokenVariant as Token;
use ConstantExpressionEvaluationError as EvalErr;
let mut stack = Vec::new();
macro_rules! push {
($value:expr) => { stack.push($value) };
}
macro_rules! pop {
($name:ident) => { let $name = match stack.pop() {
Some(value) => value,
None => return Err(EvalErr::StackUnderflow),
}; };
}
macro_rules! truth {
($bool:expr) => { match $bool { true => 1, false => 0 } };
}
for token in &self.tokens {
match &token.variant {
Token::IntegerLiteral(value) => push!(*value),
Token::SymbolReference(name) => match environment.get_integer(name) {
Ok(value) => push!(value),
Err(_) => todo!(),
}
Token::Operator(operator) => match operator {
Operator::Equal => { pop!(b); pop!(a); push!(truth!(a==b)) },
Operator::NotEqual => { pop!(b); pop!(a); push!(truth!(a!=b)) },
Operator::LessThan => { pop!(b); pop!(a); push!(truth!(a < b)) },
Operator::GreaterThan => { pop!(b); pop!(a); push!(truth!(a > b)) },
Operator::Add => { pop!(b); pop!(a); push!(a + b) },
Operator::Subtract => { pop!(b); pop!(a); push!(a - b) },
Operator::LeftShift => { pop!(b); pop!(a); push!(a << b) },
Operator::RightShift => { pop!(b); pop!(a); push!(a >> b) },
Operator::And => { pop!(b); pop!(a); push!(a & b) },
Operator::Or => { pop!(b); pop!(a); push!(a | b) },
Operator::Xor => { pop!(b); pop!(a); push!(a ^ b) },
Operator::Not => { pop!(a); push!(!a) },
}
Token::Error(_) => (),
}
}
match stack.len() {
0 => Err(EvalErr::NoReturnValue),
1 => Ok(stack[0]),
_ => Err(EvalErr::MultipleReturnValues),
}
}
}
pub enum ConstantExpressionEvaluationError {
StackUnderflow,
MultipleReturnValues,
NoReturnValue,
}
impl std::fmt::Debug for ConstantExpression {
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
use ConstantExpressionTokenVariant as TokenVar;
for (i, token) in self.tokens.iter().enumerate() {
let string = match &token.variant {
TokenVar::SymbolReference(name) => name,
TokenVar::IntegerLiteral(value) => &value.to_string(),
TokenVar::Operator(operator) => match operator {
Operator::Equal => "=",
Operator::NotEqual => "!",
Operator::LessThan => "<",
Operator::GreaterThan => ">",
Operator::Add => "+",
Operator::Subtract => "-",
Operator::LeftShift => "<<",
Operator::RightShift => ">>",
Operator::And => "&",
Operator::Or => "|",
Operator::Xor => "^",
Operator::Not => "~",
}
TokenVar::Error(_) => "<error>",
};
match i {
0 => write!(f, "{string}")?,
_ => write!(f, " {string}")?,
}
}
return Ok(());
}
}
|
