77 lines
2.9 KiB
Markdown
77 lines
2.9 KiB
Markdown
|
```
|
||
|
|
metadata.title = "Part 3: Basic Evaluation"
|
||
|
|
metadata.tags = ["build a programming language", "rust"]
|
||
|
|
metadata.date = "2021-04-15 17:00:42 -0400"
|
||
|
|
metadata.shortDesc = "A bad calculator."
|
||
|
|
metadata.slug = "evaluation"
|
||
|
|
metadata.preamble = `<p style="font-style: italic;">This post is part of a <a href="/build-a-programming-language/" data-link="/build-a-programming-language/">series</a> about learning Rust and building a small programming language.</p><hr>`
|
||
|
|
```
|
||
|
|
|
||
|
|
Last time I said operator precedence was going to be next. Well, if you've read the title, you know that's not the case. I decided I really wanted to see this actually run^[evaluate] some code^[a single expression], so let's do that.
|
||
|
|
|
||
|
|
<!-- excerpt-end -->
|
||
|
|
|
||
|
|
First, there needs to be something to actually store values during the evaluation process. For this, I used yet another enum. It only has one case for now because we can currently only lex and parse integer values and one arithmetic operator.
|
||
|
|
|
||
|
|
```rust
|
||
|
|
enum Value {
|
||
|
|
Integer(i64),
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
There's also a helper function to extract the underlying integer from a value in places where we're certain it's going to be an integer:
|
||
|
|
|
||
|
|
```rust
|
||
|
|
impl Value {
|
||
|
|
fn expect_integer(&self, &msg) -> i64 {
|
||
|
|
match self {
|
||
|
|
Value::Integer(n) => *n,
|
||
|
|
_ => panic!("{}", msg),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
The compiler warns about the unreachable match arm, but it'll be useful once there are more types of values. (Once again, actual error reporting will wait.)
|
||
|
|
|
||
|
|
The actual evaulation starts in the `eval` function which takes a reference to the node to evaluate and returns a `Value` representing its result.
|
||
|
|
|
||
|
|
For integer nodes, the value of the AST node is wrapped in a Value and returned directly. For binary operator (i.e. addition) nodes the left- and right-hand values are extracted and another function is called to perform the operation.
|
||
|
|
|
||
|
|
```rust
|
||
|
|
fn eval(node: &Node) -> Value {
|
||
|
|
match node {
|
||
|
|
Node::Integer(n) => Value::Integer(*n),
|
||
|
|
Node::BinaryOp { left, right } => eval_binary_op(left, right),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
This `eval_binary_op` function takes each of the nodes and calls `eval` with it. By doing this, it recurses through the the AST evaluating each node in a depth-first manner. It then turns each value into an integer (panicking if either isn't what it expects) and returns a new Value with the values added together.
|
||
|
|
|
||
|
|
```rust
|
||
|
|
fn eval_binary_op(left: &Node, right: &Node) -> Value {
|
||
|
|
let left = eval(left).expect_integer("left hand side of binary operator must be an integer");
|
||
|
|
let right = eval(right).expect_integer("right hand side of binary operator must be an integer");
|
||
|
|
Value::Integer(left + right)
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
And with that surpisingly small amount of code, I've got a very dumb calculator that can perform arbitrary additions:
|
||
|
|
|
||
|
|
```rust
|
||
|
|
fn main() {
|
||
|
|
let tokens = tokenize("1 + 2 + 3");
|
||
|
|
if let Some(node) = parse(tokens) {
|
||
|
|
println!("result: {:?}", eval(&node));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
```
|
||
|
|
|
||
|
|
```sh
|
||
|
|
$ cargo run
|
||
|
|
result: Integer(6)
|
||
|
|
```
|
||
|
|
|
||
|
|
Next time, I'll add some more operators and actually get around to operator precedence.
|