2021-09-18 18:00:22 +00:00
|
|
|
package lox;
|
|
|
|
|
2021-09-18 20:09:43 +00:00
|
|
|
import java.util.ArrayList;
|
2021-09-23 01:42:06 +00:00
|
|
|
import java.util.Arrays;
|
2021-09-18 18:00:22 +00:00
|
|
|
import java.util.List;
|
|
|
|
|
|
|
|
import static lox.TokenType.*;
|
|
|
|
|
|
|
|
class Parser {
|
|
|
|
private static class ParseError extends RuntimeException {}
|
|
|
|
|
|
|
|
private final List<Token> tokens;
|
|
|
|
private int current = 0;
|
|
|
|
|
|
|
|
Parser(List<Token> tokens) {
|
|
|
|
this.tokens = tokens;
|
|
|
|
}
|
|
|
|
|
2021-09-18 20:09:43 +00:00
|
|
|
List<Stmt> parse() {
|
|
|
|
List<Stmt> statements = new ArrayList<>();
|
|
|
|
while (!isAtEnd()) {
|
2021-09-19 18:13:47 +00:00
|
|
|
statements.add(declaration());
|
2021-09-18 18:00:22 +00:00
|
|
|
}
|
2021-09-18 20:09:43 +00:00
|
|
|
return statements;
|
|
|
|
}
|
|
|
|
|
2021-09-19 18:13:47 +00:00
|
|
|
private Stmt declaration() {
|
|
|
|
try {
|
2021-09-26 16:54:32 +00:00
|
|
|
if (match(FUN)) {
|
|
|
|
return function("function");
|
|
|
|
}
|
2021-09-19 18:13:47 +00:00
|
|
|
if (match(VAR)) {
|
|
|
|
return varDeclaration();
|
|
|
|
}
|
|
|
|
return statement();
|
|
|
|
} catch (ParseError error) {
|
|
|
|
synchronize();
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private Stmt varDeclaration() {
|
|
|
|
Token name = consume(IDENTIFIER, "Expect variable name.");
|
|
|
|
|
|
|
|
Expr initializer = null;
|
|
|
|
if (match(EQUAL)) {
|
|
|
|
initializer = expression();
|
|
|
|
}
|
|
|
|
consume(SEMICOLON, "Expect semicolon.");
|
|
|
|
return new Stmt.Var(name, initializer);
|
|
|
|
}
|
|
|
|
|
2021-09-18 20:09:43 +00:00
|
|
|
private Stmt statement() {
|
2021-09-23 01:42:06 +00:00
|
|
|
if (match(FOR)) {
|
|
|
|
return forStatement();
|
|
|
|
}
|
|
|
|
if (match(IF)) {
|
|
|
|
return ifStatement();
|
|
|
|
}
|
2021-09-18 20:09:43 +00:00
|
|
|
if (match(PRINT)) {
|
|
|
|
return printStatement();
|
|
|
|
}
|
2021-09-26 16:54:32 +00:00
|
|
|
if (match(RETURN)) {
|
|
|
|
return returnStatement();
|
|
|
|
}
|
2021-09-23 01:42:06 +00:00
|
|
|
if (match(WHILE)) {
|
|
|
|
return whileStatement();
|
|
|
|
}
|
2021-09-19 18:46:00 +00:00
|
|
|
if (match(LEFT_BRACE)) {
|
|
|
|
return new Stmt.Block(block());
|
|
|
|
}
|
2021-09-18 20:09:43 +00:00
|
|
|
return expressionStatement();
|
|
|
|
}
|
|
|
|
|
|
|
|
private Stmt printStatement() {
|
|
|
|
Expr value = expression();
|
|
|
|
consume(SEMICOLON, "Expect ';' after value.");
|
|
|
|
return new Stmt.Print(value);
|
|
|
|
}
|
|
|
|
|
2021-09-26 16:54:32 +00:00
|
|
|
private Stmt returnStatement() {
|
|
|
|
Token keyword = previous();
|
|
|
|
Expr value = null;
|
|
|
|
if (!check(SEMICOLON)) {
|
|
|
|
value = expression();
|
|
|
|
}
|
|
|
|
consume(SEMICOLON, "Expect ';' after return value");
|
|
|
|
return new Stmt.Return(keyword, value);
|
|
|
|
}
|
|
|
|
|
2021-09-23 01:42:06 +00:00
|
|
|
private Stmt whileStatement() {
|
|
|
|
consume(LEFT_PAREN, "Expect '(' after 'while");
|
|
|
|
Expr condition = expression();
|
|
|
|
consume(RIGHT_PAREN, "Expect ')' after while condition");
|
|
|
|
Stmt body = statement();
|
|
|
|
|
|
|
|
return new Stmt.While(condition, body);
|
|
|
|
}
|
|
|
|
|
2021-09-18 20:09:43 +00:00
|
|
|
private Stmt expressionStatement() {
|
|
|
|
Expr value = expression();
|
|
|
|
consume(SEMICOLON, "Expect ';' after value.");
|
|
|
|
return new Stmt.Expression(value);
|
2021-09-18 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
2021-09-26 16:54:32 +00:00
|
|
|
private Stmt function(String kind) {
|
|
|
|
Token name = consume(IDENTIFIER, "Expect " + kind + " name.");
|
|
|
|
consume(LEFT_PAREN, "Expect '(' after " + kind + "name");
|
|
|
|
List<Token> parameters = new ArrayList<>();
|
|
|
|
if (!check(RIGHT_PAREN)) {
|
|
|
|
do {
|
|
|
|
if (parameters.size() >= 255) {
|
|
|
|
error(peek(), "Can't have more than 255 parameters.");
|
|
|
|
}
|
|
|
|
parameters.add(consume(IDENTIFIER, "Expect parameter name."));
|
|
|
|
} while (match(COMMA));
|
|
|
|
}
|
|
|
|
consume(RIGHT_PAREN, "Expect ')' after parameters.");
|
|
|
|
consume(LEFT_BRACE, "Expect '{' before " + kind + " body.");
|
|
|
|
List<Stmt> body = block();
|
|
|
|
return new Stmt.Function(name, parameters, body);
|
|
|
|
}
|
|
|
|
|
2021-09-23 01:42:06 +00:00
|
|
|
private Stmt ifStatement() {
|
|
|
|
consume(LEFT_PAREN, "Expect '(' after 'if'.");
|
|
|
|
Expr condition = expression();
|
|
|
|
consume(RIGHT_PAREN, "Expect ')' after if condition");
|
|
|
|
|
|
|
|
Stmt thenBranch = statement();
|
|
|
|
Stmt elseBranch = null;
|
|
|
|
if (match(ELSE)) {
|
|
|
|
elseBranch = statement();
|
|
|
|
}
|
|
|
|
return new Stmt.If(condition, thenBranch, elseBranch);
|
|
|
|
}
|
|
|
|
|
|
|
|
private Stmt forStatement() {
|
|
|
|
consume(LEFT_PAREN, "Expect '(' after 'for'.");
|
|
|
|
|
|
|
|
Stmt initializer;
|
|
|
|
if (match(SEMICOLON)) {
|
|
|
|
initializer = null;
|
|
|
|
} else if (match(VAR)) {
|
|
|
|
initializer = varDeclaration();
|
|
|
|
} else {
|
|
|
|
initializer = expressionStatement();
|
|
|
|
}
|
|
|
|
|
|
|
|
Expr condition = null;
|
|
|
|
if (!check(SEMICOLON)) {
|
|
|
|
condition = expression();
|
|
|
|
}
|
|
|
|
consume(SEMICOLON, "Expect ';' after loop condition.");
|
|
|
|
|
|
|
|
Expr increment = null;
|
|
|
|
if (!check(RIGHT_PAREN)) {
|
|
|
|
increment = expression();
|
|
|
|
}
|
|
|
|
consume(RIGHT_PAREN, "Expect ')' after for clauses");
|
|
|
|
Stmt body = statement();
|
|
|
|
|
|
|
|
if (increment != null) {
|
|
|
|
// move incrementer into the body
|
|
|
|
body = new Stmt.Block(Arrays.asList(body, new Stmt.Expression(increment)));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (condition == null) {
|
|
|
|
// set an infinite loop up if no condition given
|
|
|
|
condition = new Expr.Literal(true);
|
|
|
|
}
|
|
|
|
body = new Stmt.While(condition, body);
|
|
|
|
|
|
|
|
if (initializer != null) {
|
|
|
|
// insert the initializer before the while statement
|
|
|
|
body = new Stmt.Block(Arrays.asList(initializer, body));
|
|
|
|
}
|
|
|
|
|
|
|
|
return body;
|
|
|
|
}
|
|
|
|
|
2021-09-19 18:46:00 +00:00
|
|
|
private List<Stmt> block() {
|
|
|
|
List<Stmt> statements = new ArrayList<>();
|
|
|
|
|
|
|
|
while (!check(RIGHT_BRACE) && !isAtEnd()) {
|
|
|
|
statements.add(declaration());
|
|
|
|
}
|
|
|
|
consume(RIGHT_BRACE, "Expect '}' after block.");
|
|
|
|
return statements;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr assignment() {
|
2021-09-23 01:42:06 +00:00
|
|
|
Expr expr = or();
|
2021-09-19 18:46:00 +00:00
|
|
|
|
|
|
|
if (match(EQUAL)) {
|
|
|
|
Token equals = previous();
|
|
|
|
Expr value = assignment();
|
|
|
|
|
|
|
|
if (expr instanceof Expr.Variable) {
|
|
|
|
Token name = ((Expr.Variable)expr).name;
|
|
|
|
return new Expr.Assign(name, value);
|
|
|
|
}
|
|
|
|
// does not throw because parsing _can_ continue
|
|
|
|
error(equals, "Invalid assignment target.");
|
|
|
|
}
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
2021-09-23 01:42:06 +00:00
|
|
|
private Expr or() {
|
|
|
|
Expr expr = and();
|
|
|
|
|
|
|
|
while (match(OR)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = and();
|
|
|
|
expr = new Expr.Logical(expr, operator, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr and() {
|
|
|
|
Expr expr = equality();
|
|
|
|
|
|
|
|
while (match(AND)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = equality();
|
|
|
|
expr = new Expr.Logical(expr, operator, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
2021-09-18 18:00:22 +00:00
|
|
|
private Expr expression() {
|
2021-09-19 18:46:00 +00:00
|
|
|
return assignment();
|
2021-09-18 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private Expr equality() {
|
|
|
|
Expr expr = comparison();
|
|
|
|
while (match(BANG_EQUAL, EQUAL_EQUAL)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = comparison();
|
|
|
|
expr = new Expr.Binary(expr, operator, right);
|
|
|
|
}
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr comparison() {
|
|
|
|
Expr expr = term();
|
|
|
|
while (match(GREATER, GREATER_EQUAL, LESS, LESS_EQUAL)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = term();
|
|
|
|
expr = new Expr.Binary(expr, operator, right);
|
|
|
|
}
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr term() {
|
|
|
|
Expr expr = factor();
|
|
|
|
while (match(PLUS, MINUS)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = factor();
|
|
|
|
expr = new Expr.Binary(expr, operator, right);
|
|
|
|
}
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr factor() {
|
|
|
|
Expr expr = unary();
|
|
|
|
while (match(STAR, SLASH)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = unary();
|
|
|
|
expr = new Expr.Binary(expr, operator, right);
|
|
|
|
}
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr unary() {
|
|
|
|
if (match(BANG, MINUS)) {
|
|
|
|
Token operator = previous();
|
|
|
|
Expr right = unary();
|
|
|
|
return new Expr.Unary(operator, right);
|
|
|
|
}
|
2021-09-26 16:54:32 +00:00
|
|
|
return call();
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr call() {
|
|
|
|
Expr expr = primary();
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
if (match(LEFT_PAREN)) {
|
|
|
|
expr = finishCall(expr);
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Expr finishCall(Expr callee) {
|
|
|
|
List<Expr> arguments = new ArrayList<>();
|
|
|
|
|
|
|
|
if (!check(RIGHT_PAREN)) {
|
|
|
|
do {
|
|
|
|
arguments.add(expression());
|
|
|
|
} while (match(COMMA));
|
|
|
|
}
|
|
|
|
Token paren = consume(RIGHT_PAREN, "Expected ')' after argument list");
|
|
|
|
|
|
|
|
if (arguments.size() >= 255) {
|
|
|
|
error(peek(), "Can't have more than 255 arguments");
|
|
|
|
}
|
|
|
|
|
|
|
|
return new Expr.Call(callee, paren, arguments);
|
2021-09-18 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private Expr primary() {
|
|
|
|
if (match(FALSE)) {
|
|
|
|
return new Expr.Literal(false);
|
|
|
|
}
|
|
|
|
if (match(TRUE)) {
|
|
|
|
return new Expr.Literal(true);
|
|
|
|
}
|
|
|
|
if (match(NIL)) {
|
|
|
|
return new Expr.Literal(null);
|
|
|
|
}
|
|
|
|
if (match(NUMBER, STRING)) {
|
|
|
|
return new Expr.Literal(previous().literal);
|
|
|
|
}
|
|
|
|
if (match(LEFT_PAREN)) {
|
|
|
|
Expr expr = expression();
|
|
|
|
consume(RIGHT_PAREN, "Expect ')' after expression.");
|
|
|
|
return new Expr.Grouping(expr);
|
|
|
|
}
|
2021-09-19 18:13:47 +00:00
|
|
|
if (match(IDENTIFIER)) {
|
|
|
|
return new Expr.Variable(previous());
|
|
|
|
}
|
2021-09-18 18:00:22 +00:00
|
|
|
|
|
|
|
throw error(peek(), "Expected expression.");
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean match(TokenType... types) {
|
|
|
|
for (TokenType type : types) {
|
|
|
|
if (check(type)) {
|
|
|
|
advance();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Token consume(TokenType type, String message) {
|
|
|
|
if (check(type)) {
|
|
|
|
return advance();
|
|
|
|
}
|
|
|
|
throw error(peek(), message);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean check(TokenType type) {
|
|
|
|
if (isAtEnd()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return peek().type == type;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Token advance() {
|
|
|
|
if (!isAtEnd()) {
|
|
|
|
current++;
|
|
|
|
}
|
|
|
|
return previous();
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean isAtEnd() {
|
|
|
|
return peek().type == EOF;
|
|
|
|
}
|
|
|
|
|
|
|
|
private Token peek() {
|
|
|
|
return tokens.get(current);
|
|
|
|
}
|
|
|
|
|
|
|
|
private Token previous() {
|
|
|
|
return tokens.get(current - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
private ParseError error(Token token, String message) {
|
|
|
|
Lox.error(token, message);
|
|
|
|
return new ParseError();
|
|
|
|
}
|
|
|
|
|
|
|
|
private void synchronize() {
|
|
|
|
advance();
|
|
|
|
while (!isAtEnd()) {
|
|
|
|
if (previous().type == SEMICOLON) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch (peek().type) {
|
2021-09-19 18:13:47 +00:00
|
|
|
case CLASS, FOR, FUN, IF, PRINT, RETURN, VAR, WHILE:
|
2021-09-18 18:00:22 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
advance();
|
|
|
|
}
|
|
|
|
}
|