v6/site/posts/2021-05-03-statements.md

98 lines
2.7 KiB
Markdown
Raw Normal View History

2022-12-10 18:15:32 +00:00
```
title = "Part 9: Statements"
tags = ["build a programming language", "rust"]
date = "2021-05-03 17:46:42 -0400"
slug = "statements"
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>'
```
So the parser can handle a single expression, but since we're not building a Lisp, that's not enough. It needs to handle multiple statements. For context, an expression is a piece of code that represents a value whereas a statement is a piece of code that can be executed but does not result in a value.
<!-- excerpt-end -->
In the AST, there's a new top-level type: `Statement`. For now, the only type of statement is one that contains an expression and nothing else.
```rust
enum Statement {
Expr(Node),
}
```
The top level `parse` function has also changed to reflect this. It now returns a vector of statements, instead of a single expression node. The `do_parse` function continues to work exactly as it has, but is renamed `parse_expression` to since that's what it's actually doing.
```rust
fn parse(tokens: &[Token]) -> Vec<Statement> {
let mut it = tokens.iter().peekable();
let mut statements: Vec<Statement> = vec![];
while let Some(_) = it.peek() {
match parse_statement(&mut it) {
Some(statement) => statements.push(statement),
None => (),
}
}
statements
}
```
The `parse_statement` function does exactly what the name suggests.
```rust
fn parse_statement<'a, I: Iterator<Item = &'a Token>>(it: &mut Peekable<'a, I>) -> Option<Statement> {
if it.peek().is_none() {
return None;
}
let node = parse_expression(it).map(|node| Statement::Expr(node));
node
}
```
With that in place, parsing multiple statements is easy. The only change is that, after successfully parsing a statement, we need to consume a semicolon if there is one. Then, the `parse` loop will continue and the next statement can be parsed.
```rust
fn parse_statement<'a, I: Iterator<Item = &'a Token>>(it: &mut Peekable<'a, I>) -> Option<Statement> {
// ...
match it.peek() {
Some(Token::Semicolon) => {
it.next();
}
Some(tok) => {
panic!("unexpected token {:?} after statement", tok);
}
None => (),
}
node
}
```
I intend to make semicolons optional and allow newline-delimited statements, but that is more complicated and will have to wait for another time. For now, this is good enough:
```rust
fn main() {
let tokens = tokenize("1 + 2; foo();");
print("statements: {:?}", parse(&tokens));
}
```
```sh
$ cargo run
statements: [
Expr(
BinaryOp {
left: Integer(1),
op: Add,
right: Integer(2),
},
),
Expr(
Call {
name: "foo",
params: [],
},
),
]
```