1use anyhow::{Error, Result};
2
3use crate::{
4 tokenizer::{
5 consumer::Cursor,
6 token::{operator::Operator, ttype::TokenType},
7 },
8 util::AsCharVec,
9};
10
11use self::expr::{Expression, Operation};
12
13pub mod args;
14pub mod call;
15pub mod expr;
16pub mod func;
17pub mod ifelse;
18pub mod var;
19
20pub fn or_err<T>(opt: Option<T>, err: Error) -> Result<T> {
21 opt.ok_or(err)
22}
23
24pub fn is_next_decimal(iter: &mut Cursor<TokenType>) -> bool {
25 if let Some(item) = iter.peek(1) {
26 if let Ok(op) = item.get_operator() {
27 if op == Operator::Decimal {
28 return true;
29 }
30 }
31 }
32
33 return false;
34}
35
36pub struct AstParser {
37 pub iter: Cursor<TokenType>,
38 pub tokens: Vec<TokenType>,
39 pub exprs: Vec<Expression>,
40}
41
42impl AstParser {
43 pub fn new(tokens: Vec<TokenType>) -> Self {
44 Self {
45 iter: Cursor::new(tokens.clone()),
46 tokens,
47 exprs: Vec::new(),
48 }
49 }
50
51 pub fn parse(&mut self) -> Result<()> {
52 while self.iter.has_next() {
53 let expr = self.parse_one()?;
54
55 self.exprs.push(expr);
56 }
57
58 self.exprs = self
59 .exprs
60 .iter()
61 .cloned()
62 .filter(|v| v != &Expression::None)
63 .collect();
64
65 Ok(())
66 }
67
68 pub fn parse_one(&mut self) -> Result<Expression> {
69 Ok(match self.iter.next().unwrap() {
70 TokenType::Name(name) => match String::from_iter(name).as_str() {
71 "fn" => self.parse_fn()?,
72 "if" => self.parse_if()?,
73 "let" => self.parse_let()?,
74 "return" => Expression::Return(Box::new(self.parse_one()?)),
75
76 name => {
77 let peeked = self
78 .iter
79 .peek_until(TokenType::Operator(Operator::OpenParens));
80
81 if peeked
82 .iter()
83 .all(|v| v == &TokenType::Operator(Operator::Decimal) || v.is_name())
84 && peeked.contains(&TokenType::Operator(Operator::Decimal))
85 {
86 let mut names = self
87 .iter
88 .read_until(TokenType::Operator(Operator::OpenParens));
89
90 names.insert(0, TokenType::Name(name.as_char_vec()));
91
92 let mut names = names
93 .iter()
94 .cloned()
95 .filter(|v| v != &TokenType::Operator(Operator::Decimal))
96 .collect::<Vec<TokenType>>();
97
98 let method = names.pop().unwrap();
99
100 let names = names
101 .iter()
102 .map(|v| v.get_name().unwrap())
103 .collect::<Vec<String>>();
104
105 let args = self.iter.read_until_counted(
106 TokenType::Operator(Operator::OpenParens),
107 TokenType::Operator(Operator::CloseParens),
108 );
109
110 let mut parser = AstParser::new(args);
111
112 parser.parse()?;
113
114 let args = parser
115 .exprs
116 .iter()
117 .map(|v| Box::new(v.clone()))
118 .collect::<Vec<Box<Expression>>>();
119
120 return Ok(Expression::MethodCall(names, method.get_name()?, args));
121 } else if self
122 .iter
123 .next_is_peek(TokenType::Operator(Operator::OpenParens), 0)
124 .is_ok()
125 {
126 self.iter.next();
127
128 let args = self.iter.read_until_counted(
129 TokenType::Operator(Operator::OpenParens),
130 TokenType::Operator(Operator::CloseParens),
131 );
132
133 let mut parser = AstParser::new(args);
134
135 parser.parse()?;
136
137 let args = parser
138 .exprs
139 .iter()
140 .map(|v| Box::new(v.clone()))
141 .collect::<Vec<Box<Expression>>>();
142
143 return Ok(Expression::Call(name.to_string(), args));
144 } else if self
145 .iter
146 .next_is_peek(TokenType::Operator(Operator::OpenSqBracket), 0)
147 .is_ok()
148 {
149 self.iter.next();
150
151 let idx = self
152 .iter
153 .next_result("Cannot read index from array!")?
154 .get_number()?;
155
156 self.iter.next();
157
158 return Ok(Expression::Operation(Operation::Index(
159 name.to_string(),
160 idx as usize,
161 )));
162 }
163
164 Expression::Identifier(name.to_string())
165 }
166 },
167
168 TokenType::String(val) => Expression::String(String::from_iter(val)),
169
170 TokenType::Number(val) => {
171 let n: i32 =
172 String::from_iter(val.iter().map(|v| v.to_string()).collect::<Vec<String>>())
173 .parse()?;
174
175 if self
176 .iter
177 .next_is_peek(TokenType::Operator(Operator::Decimal), 0)
178 .is_ok()
179 && self.iter.peek(1).unwrap_or(TokenType::None).is_number()
180 {
181 self.iter.next();
182
183 let n2 = self.iter.next().unwrap().get_number()?;
184 let flt = format!("{}.{}", n, n2).parse::<f32>()?;
185
186 Expression::Float(flt)
187 } else {
188 Expression::Number(n)
189 }
190 }
191
192 TokenType::Operator(op) => match op {
193 Operator::Gt => {
194 let last = self.exprs.pop().unwrap();
195
196 if self
197 .iter
198 .next_is_peek(TokenType::Operator(Operator::Equals), 0)
199 .is_ok()
200 {
201 self.iter.next();
202
203 Expression::Operation(Operation::GtEq(
204 Box::new(last),
205 Box::new(self.parse_one()?),
206 ))
207 } else {
208 Expression::Operation(Operation::Gt(
209 Box::new(last),
210 Box::new(self.parse_one()?),
211 ))
212 }
213 }
214
215 _ => Expression::None,
216 },
217
218 TokenType::None => Expression::None,
219 })
220 }
221}