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
|
use crate::lex::token::Token;
use crate::lex::token::TokenVariant;
use crate::lex::token::TokenVariant::*;
use crate::parse::ast::Expression;
use anyhow::anyhow;
use anyhow::Result;
use std::iter::Peekable;
pub struct Parser<T: Iterator> {
tokens: Peekable<T>,
}
impl<T: Iterator<Item = Token>> Parser<T> {
pub fn new(tokens: T) -> Self {
Parser {
tokens: tokens.peekable(),
}
}
pub fn parse(&mut self) -> Result<Expression> {
self.expression()
}
fn expression(&mut self) -> Result<Expression> {
self.term_expression()
}
fn term_expression(&mut self) -> Result<Expression> {
let mut left = self.factor_expression()?;
while matches!(
self.tokens.peek(),
Some(Token {
variant: OpPlus | OpMinus,
..
})
) {
let op = self.tokens.next().unwrap();
let right = self.factor_expression()?;
left = Expression::Binary {
left: Box::new(left),
op,
right: Box::new(right),
};
}
Ok(left)
}
fn factor_expression(&mut self) -> Result<Expression> {
let mut left = self.unary_expression()?;
while matches!(
self.tokens.peek(),
Some(Token {
variant: OpSlash | OpStar,
..
})
) {
let op = self.tokens.next().unwrap();
let right = self.unary_expression()?;
left = Expression::Binary {
left: Box::new(left),
op,
right: Box::new(right),
};
}
Ok(left)
}
fn unary_expression(&mut self) -> Result<Expression> {
let expression = if let Some(Token {
variant: OpPlus | OpMinus | OpNot,
..
}) = self.tokens.peek()
{
Expression::Unary {
op: self.tokens.next().unwrap(),
right: Box::new(self.unary_expression()?),
}
} else {
self.unit_expression()?
};
Ok(expression)
}
fn unit_expression(&mut self) -> Result<Expression> {
if let Some(token) = self.tokens.next() {
match token.variant {
Int(_) | Float(_) => Ok(Expression::Literal(token)),
GroupOpen => {
let expression = self.expression()?;
if let Some(Token {
variant: TokenVariant::GroupClose,
..
}) = self.tokens.next()
{
Ok(Expression::Group(Box::new(expression)))
} else {
Err(anyhow!("Expected ')' after grouping."))
}
}
_ => Err(anyhow!("Unexpected token: {:?}", token.variant)),
}
} else {
Err(anyhow!("Expected expression."))
}
}
}
|
