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
use std::iter::{Enumerate, Peekable};
use crate::{
chunk::Chunk,
code::OpCode,
environment::Environment,
error::{Location, SiltError},
lexer::{Lexer, TokenResult},
token::Token,
value::Value,
};
struct Compiler {
chunk: Chunk,
iterator: Option<Peekable<Lexer>>,
// locations: Vec<Location>,
previous: Location,
// lexer: Lexer,
// parser: Parser,
// resolver: Resolver,
// interpreter: Interpreter,
}
impl Compiler {
pub fn new() -> Compiler {
Compiler {
chunk: Chunk::new(),
iterator: None,
// locations: vec![],
previous: (0, 0),
// lexer: Lexer::new(),
// parser: Parser::new(),
// resolver: Resolver::new(),
// interpreter: Interpreter::new(),
}
}
pub fn compile(&mut self, source: String, global: &mut Environment) -> Value {
let mut lexer = Lexer::new(source.to_owned());
self.iterator = Some(lexer.peekable());
// lexer.enumerate().for_each(|(i, res)| match res {
// Ok((token, location)) => {
// self.iterator.push(t);
// }
// Err(e) => {
// println!("| {}", e);
// }
// });
// let mut parser = crate::parser::parser::Parser::new(t, p, global);
// println!("|----------------");
// let mut statements = parser.parse();
// statements
// .iter()
// .enumerate()
// .for_each(|(i, e)| println!("| {} {}", i, e));
// // println!("{}", exp);
// // let val = parser.evaluate(exp);
// let err = parser.get_errors();
// if err.len() > 0 {
// println!("|----------------");
// println!("Parse Errors:");
// err.iter().for_each(|e| println!("{}", e));
// println!("-----------------");
// } else {
// println!("-----------------");
// let mut resolver = crate::resolver::Resolver::new();
// resolver.process(&mut statements);
// let res = crate::interpreter::execute(global, &statements);
// match res {
// Ok(v) => {
// println!("");
// return v;
// }
// Err(e) => {
// println!("| Runtime Errors:");
// println!("| {}", e);
// println!("-----------------");
// }
// }
// }
self.expression();
// t.iter().enumerate().for_each(|(i, t)| {
// let p = p.get(i).unwrap_or(&(0, 0));
// self.expression(t, p);
// // println!("|{}:{}| {}", p.0, p.1, t)
// });
self.emit(OpCode::RETURN, (0, 0));
Value::Nil
}
fn expression(&mut self) {}
fn emit(&mut self, op: OpCode, location: Location) {
self.chunk.write_code(op, location);
}
fn constant(&mut self, value: Value, location: Location) {
let constant = self.chunk.write_constant(value) as u8;
self.emit(OpCode::CONSTANT { constant }, location);
}
fn current_chunk(&self) -> &Chunk {
&self.chunk
}
fn eat(&mut self) {
let p = self.iterator.unwrap().next();
if let Some(Ok(t)) = p {
self.previous = t.1;
}
}
fn grouping(&mut self) {
self.expression();
expect_token!(self, CloseParen, SiltError::UnterminatedParenthesis(0, 0));
// self.consume(TokenType::RightParen, "Expect ')' after expression.");
}
// fn expression(&mut self) {}
}