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
|
use crate::errors::{report, Error, ErrorKind};
use crate::parser::{self, Declaration, Expr, Literal, Program, Statement};
use crate::scanner::{self, TokenKind};
// Run some Lox code and print it to stdout
pub fn run(code: &str) {
let chars: Vec<char> = code.chars().collect();
match scanner::scan(&chars) {
Ok(tokens) => match parser::parse(tokens) {
Ok(program) => {
println!("Program:\n{:?}", program);
if let Err(err) = run_program(&program) {
println!("Error in program: {:?}", err);
}
}
Err(errors) => report_errors(errors),
},
Err(errors) => report_errors(errors),
}
}
fn report_errors(errors: Vec<Error>) {
for error in errors {
report(&error);
}
}
// Tree-walk interpreter
fn eval_truthy(lit: &Literal) -> bool {
match lit {
Literal::Nil => false,
Literal::Boolean(b) => *b,
_ => true,
}
}
fn eval_unary<'a>(expr: &parser::Unary<'a>) -> Result<Literal, Error> {
let right = eval(&*expr.right)?;
match (&expr.operator.kind, right) {
(TokenKind::Minus, Literal::Number(num)) => Ok(Literal::Number(-num)),
(TokenKind::Bang, right) => Ok(Literal::Boolean(!eval_truthy(&right))),
(op, right) => Err(Error {
line: expr.operator.line,
kind: ErrorKind::TypeError(format!(
"Operator '{:?}' can not be called with argument '{:?}'",
op, right
)),
}),
}
}
fn eval_binary<'a>(expr: &parser::Binary<'a>) -> Result<Literal, Error> {
let left = eval(&*expr.left)?;
let right = eval(&*expr.right)?;
let result = match (&expr.operator.kind, left, right) {
// Numeric
(TokenKind::Minus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l - r),
(TokenKind::Slash, Literal::Number(l), Literal::Number(r)) => Literal::Number(l / r),
(TokenKind::Star, Literal::Number(l), Literal::Number(r)) => Literal::Number(l * r),
(TokenKind::Plus, Literal::Number(l), Literal::Number(r)) => Literal::Number(l + r),
// Strings
(TokenKind::Plus, Literal::String(l), Literal::String(r)) => {
Literal::String(format!("{}{}", l, r))
}
// Comparators (on numbers only?)
(TokenKind::Greater, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l > r),
(TokenKind::GreaterEqual, Literal::Number(l), Literal::Number(r)) => {
Literal::Boolean(l >= r)
}
(TokenKind::Less, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l < r),
(TokenKind::LessEqual, Literal::Number(l), Literal::Number(r)) => Literal::Boolean(l <= r),
// Equality
(TokenKind::Equal, l, r) => Literal::Boolean(l == r),
(TokenKind::BangEqual, l, r) => Literal::Boolean(l != r),
(op, left, right) => {
return Err(Error {
line: expr.operator.line,
kind: ErrorKind::TypeError(format!(
"Operator '{:?}' can not be called with arguments '({:?}, {:?})'",
op, left, right
)),
})
}
};
Ok(result)
}
fn eval<'a>(expr: &Expr<'a>) -> Result<Literal, Error> {
match expr {
Expr::Literal(lit) => Ok(lit.clone()),
Expr::Grouping(grouping) => eval(&*grouping.0),
Expr::Unary(unary) => eval_unary(unary),
Expr::Binary(binary) => eval_binary(binary),
}
}
fn run_stmt<'a>(stmt: &Statement<'a>) -> Result<(), Error> {
match stmt {
Statement::Expr(expr) => {
eval(expr)?;
}
Statement::Print(expr) => {
let result = eval(expr)?;
println!("{:?}", result)
}
}
Ok(())
}
fn run_program<'a>(program: &Program<'a>) -> Result<(), Error> {
for decl in program {
match decl {
Declaration::Stmt(stmt) => run_stmt(stmt)?,
}
}
Ok(())
}
|
