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
mod lexer;
use crate::ast::token::{TokenData, Token};
use crate::ast::{Program, Statement, LocalStatementData, Expression};
use crate::parser::lexer::Lexer;
#[derive(Debug, PartialEq, PartialOrd)]
enum SymbolPriority {
Lowest = 0,
Assign = 1,
Boolean = 2,
Equals = 3,
LessGreater = 4,
Sum = 5,
Product = 6,
Prefix = 7,
Call = 8,
InstanceGet = 9
}
pub struct Parser {
lexer: Option<Lexer>,
current_token_data: TokenData,
peek_token_data: TokenData
}
impl Parser {
pub fn new() -> Parser {
Parser {
lexer: None,
current_token_data: TokenData::new(Token::None, 0),
peek_token_data: TokenData::new(Token::None, 0)
}
}
pub fn parse(&mut self, source: String, filename: String) -> Result<Program, String> {
self.lexer = Some(Lexer::new(source.as_str()));
self.next_token();
self.next_token();
self.parse_program(filename)
}
fn next_token(&mut self) {
self.current_token_data = self.peek_token_data.clone();
if let Some(lexer) = self.lexer.as_mut() {
self.peek_token_data = lexer.lex();
}
}
fn parse_program(&mut self, filename: String) -> Result<Program, String> {
let mut program = Program::new(filename);
while self.current_token_data.token != Token::Eof {
program.codes.push(self.parse_statement()?);
self.next_token();
}
Ok(program)
}
fn parse_statement(&mut self) -> Result<Statement, String> {
match self.current_token_data.token {
Token::Local => self.parse_local_statement(),
Token::Return => self.parse_return_statement(),
_ => self.parse_expression_statement()
}
}
fn parse_local_statement(&mut self) -> Result<Statement, String> {
self.next_token();
let identifier = self.current_token_data.clone();
if let Token::Identifier(_) = identifier.token {
self.next_token();
} else {
return Err("Not implement yet".to_string());
};
let mut expression = None;
if self.current_token_data.token == Token::Assign {
self.next_token();
expression = Some(self.parse_expression()?);
}
Ok(Statement::Local(Box::new(LocalStatementData { identifier, expression })))
}
fn parse_return_statement(&mut self) -> Result<Statement, String> {
Err("Not implement yet".to_string())
}
fn parse_expression_statement(&mut self) -> Result<Statement, String> {
Err("Not implement yet".to_string())
}
fn parse_expression(&mut self) -> Result<Expression, String> {
Err("Not implement yet".to_string())
}
}