Compare commits
10 Commits
c4cfe0b221
...
95a4868bc7
Author | SHA1 | Date | |
---|---|---|---|
95a4868bc7 | |||
e1f123e96f | |||
c7e62694f8 | |||
0a42e90143 | |||
91982b8428 | |||
dba05187cf | |||
c9159fda81 | |||
0a892df176 | |||
a608d32f46 | |||
179c9e19df |
@ -1,15 +0,0 @@
|
|||||||
//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
|
|
||||||
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
|
|
||||||
public class Main {
|
|
||||||
public static void main(String[] args) {
|
|
||||||
//TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
|
|
||||||
// to see how IntelliJ IDEA suggests fixing it.
|
|
||||||
System.out.printf("Hello and welcome!");
|
|
||||||
|
|
||||||
for (int i = 1; i <= 5; i++) {
|
|
||||||
//TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
|
|
||||||
// for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
|
|
||||||
System.out.println("i = " + i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
83
src/lox/AstPrinter.java
Normal file
83
src/lox/AstPrinter.java
Normal file
@ -0,0 +1,83 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
public class AstPrinter implements Expr.Visitor<String> {
|
||||||
|
String print(Expr expr) {
|
||||||
|
return expr.accept(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitAssignExpr(Expr.Assign expr) {
|
||||||
|
return parenthesize(expr.name.lexeme, expr.value);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitBinaryExpr(Expr.Binary expr) {
|
||||||
|
return parenthesize(expr.operator.lexeme,
|
||||||
|
expr.left, expr.right);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitCallExpr(Expr.Call expr) {
|
||||||
|
return parenthesize(expr.paren.lexeme, expr.callee);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitGetExpr(Expr.Get expr) {
|
||||||
|
return parenthesize(expr.name.lexeme, expr.object);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitGroupingExpr(Expr.Grouping expr) {
|
||||||
|
return parenthesize("group", expr.expression);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitLiteralExpr(Expr.Literal expr) {
|
||||||
|
if (expr.value == null) return "nil";
|
||||||
|
return expr.value.toString();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitLogicalExpr(Expr.Logical expr) {
|
||||||
|
return parenthesize(expr.operator.lexeme, expr.left, expr.right);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitSetExpr(Expr.Set expr) {
|
||||||
|
return parenthesize(expr.name.lexeme, expr.object, expr.value);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitSuperExpr(Expr.Super expr) {
|
||||||
|
return parenthesize(expr.method.lexeme);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitThisExpr(Expr.This expr) {
|
||||||
|
return parenthesize(expr.keyword.lexeme);
|
||||||
|
}
|
||||||
|
// https://craftinginterpreters.com/classes.html#invalid-uses-of-this
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitUnaryExpr(Expr.Unary expr) {
|
||||||
|
return parenthesize(expr.operator.lexeme, expr.right);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String visitVariableExpr(Expr.Variable expr) {
|
||||||
|
return parenthesize(expr.name.lexeme);
|
||||||
|
}
|
||||||
|
|
||||||
|
private String parenthesize(String name, Expr... exprs) {
|
||||||
|
StringBuilder builder = new StringBuilder();
|
||||||
|
|
||||||
|
builder.append("(").append(name);
|
||||||
|
for (Expr expr : exprs) {
|
||||||
|
builder.append(" ");
|
||||||
|
builder.append(expr.accept(this));
|
||||||
|
}
|
||||||
|
builder.append(")");
|
||||||
|
|
||||||
|
return builder.toString();
|
||||||
|
}
|
||||||
|
}
|
64
src/lox/Environment.java
Normal file
64
src/lox/Environment.java
Normal file
@ -0,0 +1,64 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
public class Environment {
|
||||||
|
final Environment enclosing;
|
||||||
|
private final Map<String, Object> values = new HashMap<>();
|
||||||
|
|
||||||
|
Environment() {
|
||||||
|
enclosing = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
Environment(Environment enclosing) {
|
||||||
|
this.enclosing = enclosing;
|
||||||
|
}
|
||||||
|
|
||||||
|
Object get(Token name) {
|
||||||
|
if (values.containsKey(name.lexeme)) {
|
||||||
|
return values.get(name.lexeme);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (enclosing != null) return enclosing.get(name);
|
||||||
|
|
||||||
|
throw new RuntimeError(name,
|
||||||
|
"Undefined variable '" + name.lexeme + "'.");
|
||||||
|
}
|
||||||
|
|
||||||
|
void assign(Token name, Object value) {
|
||||||
|
if (values.containsKey(name.lexeme)) {
|
||||||
|
values.put(name.lexeme, value);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (enclosing != null) {
|
||||||
|
enclosing.assign(name, value);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new RuntimeError(name,
|
||||||
|
"Undefined variable '" + name.lexeme + "'.");
|
||||||
|
}
|
||||||
|
|
||||||
|
void define(String name, Object value) {
|
||||||
|
values.put(name, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
Environment ancestor(int distance) {
|
||||||
|
Environment environment = this;
|
||||||
|
for (int i = 0; i < distance; i++) {
|
||||||
|
environment = environment.enclosing;
|
||||||
|
}
|
||||||
|
|
||||||
|
return environment;
|
||||||
|
}
|
||||||
|
|
||||||
|
Object getAt(int distance, String name) {
|
||||||
|
return ancestor(distance).values.get(name);
|
||||||
|
}
|
||||||
|
|
||||||
|
void assignAt(int distance, Token name, Object value) {
|
||||||
|
ancestor(distance).values.put(name.lexeme, value);
|
||||||
|
}
|
||||||
|
}
|
190
src/lox/Expr.java
Normal file
190
src/lox/Expr.java
Normal file
@ -0,0 +1,190 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
abstract class Expr {
|
||||||
|
interface Visitor<R> {
|
||||||
|
R visitAssignExpr(Assign expr);
|
||||||
|
R visitBinaryExpr(Binary expr);
|
||||||
|
R visitCallExpr(Call expr);
|
||||||
|
R visitGetExpr(Get expr);
|
||||||
|
R visitGroupingExpr(Grouping expr);
|
||||||
|
R visitLiteralExpr(Literal expr);
|
||||||
|
R visitLogicalExpr(Logical expr);
|
||||||
|
R visitSetExpr(Set expr);
|
||||||
|
R visitSuperExpr(Super expr);
|
||||||
|
R visitThisExpr(This expr);
|
||||||
|
R visitUnaryExpr(Unary expr);
|
||||||
|
R visitVariableExpr(Variable expr);
|
||||||
|
}
|
||||||
|
static class Assign extends Expr {
|
||||||
|
Assign(Token name, Expr value) {
|
||||||
|
this.name = name;
|
||||||
|
this.value = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitAssignExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token name;
|
||||||
|
final Expr value;
|
||||||
|
}
|
||||||
|
static class Binary extends Expr {
|
||||||
|
Binary(Expr left, Token operator, Expr right) {
|
||||||
|
this.left = left;
|
||||||
|
this.operator = operator;
|
||||||
|
this.right = right;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitBinaryExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr left;
|
||||||
|
final Token operator;
|
||||||
|
final Expr right;
|
||||||
|
}
|
||||||
|
static class Call extends Expr {
|
||||||
|
Call(Expr callee, Token paren, List<Expr> arguments) {
|
||||||
|
this.callee = callee;
|
||||||
|
this.paren = paren;
|
||||||
|
this.arguments = arguments;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitCallExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr callee;
|
||||||
|
final Token paren;
|
||||||
|
final List<Expr> arguments;
|
||||||
|
}
|
||||||
|
static class Get extends Expr {
|
||||||
|
Get(Expr object, Token name) {
|
||||||
|
this.object = object;
|
||||||
|
this.name = name;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitGetExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr object;
|
||||||
|
final Token name;
|
||||||
|
}
|
||||||
|
static class Grouping extends Expr {
|
||||||
|
Grouping(Expr expression) {
|
||||||
|
this.expression = expression;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitGroupingExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr expression;
|
||||||
|
}
|
||||||
|
static class Literal extends Expr {
|
||||||
|
Literal(Object value) {
|
||||||
|
this.value = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitLiteralExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Object value;
|
||||||
|
}
|
||||||
|
static class Logical extends Expr {
|
||||||
|
Logical(Expr left, Token operator, Expr right) {
|
||||||
|
this.left = left;
|
||||||
|
this.operator = operator;
|
||||||
|
this.right = right;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitLogicalExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr left;
|
||||||
|
final Token operator;
|
||||||
|
final Expr right;
|
||||||
|
}
|
||||||
|
static class Set extends Expr {
|
||||||
|
Set(Expr object, Token name, Expr value) {
|
||||||
|
this.object = object;
|
||||||
|
this.name = name;
|
||||||
|
this.value = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitSetExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr object;
|
||||||
|
final Token name;
|
||||||
|
final Expr value;
|
||||||
|
}
|
||||||
|
static class Super extends Expr {
|
||||||
|
Super(Token keyword, Token method) {
|
||||||
|
this.keyword = keyword;
|
||||||
|
this.method = method;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitSuperExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token keyword;
|
||||||
|
final Token method;
|
||||||
|
}
|
||||||
|
static class This extends Expr {
|
||||||
|
This(Token keyword) {
|
||||||
|
this.keyword = keyword;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitThisExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token keyword;
|
||||||
|
}
|
||||||
|
static class Unary extends Expr {
|
||||||
|
Unary(Token operator, Expr right) {
|
||||||
|
this.operator = operator;
|
||||||
|
this.right = right;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitUnaryExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token operator;
|
||||||
|
final Expr right;
|
||||||
|
}
|
||||||
|
static class Variable extends Expr {
|
||||||
|
Variable(Token name) {
|
||||||
|
this.name = name;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitVariableExpr(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token name;
|
||||||
|
}
|
||||||
|
|
||||||
|
abstract <R> R accept(Visitor<R> visitor);
|
||||||
|
}
|
389
src/lox/Interpreter.java
Normal file
389
src/lox/Interpreter.java
Normal file
@ -0,0 +1,389 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
public class Interpreter implements Expr.Visitor<Object>,
|
||||||
|
Stmt.Visitor<Void> {
|
||||||
|
final Environment globals = new Environment();
|
||||||
|
private Environment environment = globals;
|
||||||
|
private final Map<Expr, Integer> locals = new HashMap<>();
|
||||||
|
|
||||||
|
Interpreter() {
|
||||||
|
globals.define("clock", new LoxCallable() {
|
||||||
|
@Override
|
||||||
|
public int arity() {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object call(Interpreter interpreter, List<Object> arguments) {
|
||||||
|
return (double) System.currentTimeMillis() / 1000.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String toString() {
|
||||||
|
return "<native fn>";
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
void interpret(List<Stmt> statements) {
|
||||||
|
try {
|
||||||
|
for (Stmt statement : statements) {
|
||||||
|
execute(statement);
|
||||||
|
}
|
||||||
|
} catch (RuntimeError error) {
|
||||||
|
Lox.runtimeError(error);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitAssignExpr(Expr.Assign expr) {
|
||||||
|
Object value = evaluate(expr.value);
|
||||||
|
|
||||||
|
Integer distance = locals.get(expr);
|
||||||
|
if (distance != null) {
|
||||||
|
environment.assignAt(distance, expr.name, value);
|
||||||
|
} else {
|
||||||
|
globals.assign(expr.name, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitBinaryExpr(Expr.Binary expr) {
|
||||||
|
Object left = evaluate(expr.left);
|
||||||
|
Object right = evaluate(expr.right);
|
||||||
|
|
||||||
|
switch (expr.operator.type) {
|
||||||
|
case GREATER:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left > (double) right;
|
||||||
|
case GREATER_EQUAL:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left >= (double) right;
|
||||||
|
case LESS:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left < (double) right;
|
||||||
|
case LESS_EQUAL:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left <= (double) right;
|
||||||
|
case MINUS:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left - (double) right;
|
||||||
|
case PLUS:
|
||||||
|
if (left instanceof Double && right instanceof Double) {
|
||||||
|
return (double) left + (double) right;
|
||||||
|
}
|
||||||
|
if (left instanceof String && right instanceof String) {
|
||||||
|
return left + (String) right;
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new RuntimeError(expr.operator,
|
||||||
|
"Operands must be two numbers or two strings.");
|
||||||
|
case SLASH:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left / (double) right;
|
||||||
|
case STAR:
|
||||||
|
checkNumberOperands(expr.operator, left, right);
|
||||||
|
return (double) left * (double) right;
|
||||||
|
case BANG_EQUAL:
|
||||||
|
return !isEqual(left, right);
|
||||||
|
case EQUAL_EQUAL:
|
||||||
|
return isEqual(left, right);
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitCallExpr(Expr.Call expr) {
|
||||||
|
Object callee = evaluate(expr.callee);
|
||||||
|
|
||||||
|
List<Object> arguments = new ArrayList<>();
|
||||||
|
for (Expr argument : expr.arguments) {
|
||||||
|
arguments.add(evaluate(argument));
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(callee instanceof LoxCallable function)) {
|
||||||
|
throw new RuntimeError(expr.paren,
|
||||||
|
"Can only call functions and classes.");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (arguments.size() != function.arity()) {
|
||||||
|
throw new RuntimeError(expr.paren, "Expected " +
|
||||||
|
function.arity() + " arguments but got " +
|
||||||
|
arguments.size() + ".");
|
||||||
|
}
|
||||||
|
|
||||||
|
return function.call(this, arguments);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitGetExpr(Expr.Get expr) {
|
||||||
|
Object object = evaluate(expr.object);
|
||||||
|
if (object instanceof LoxInstance) {
|
||||||
|
return ((LoxInstance) object).get(expr.name);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new RuntimeError(expr.name,
|
||||||
|
"Only instances have properties.");
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitGroupingExpr(Expr.Grouping expr) {
|
||||||
|
return evaluate(expr.expression);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitLiteralExpr(Expr.Literal expr) {
|
||||||
|
return expr.value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitLogicalExpr(Expr.Logical expr) {
|
||||||
|
Object left = evaluate(expr.left);
|
||||||
|
|
||||||
|
if (expr.operator.type == TokenType.OR) {
|
||||||
|
if (isTruthy(left)) return left;
|
||||||
|
} else {
|
||||||
|
if (!isTruthy(left)) return left;
|
||||||
|
}
|
||||||
|
|
||||||
|
return evaluate(expr.right);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitSetExpr(Expr.Set expr) {
|
||||||
|
Object object = evaluate(expr.object);
|
||||||
|
|
||||||
|
if (!(object instanceof LoxInstance)) {
|
||||||
|
throw new RuntimeError(expr.name,
|
||||||
|
"Only instances have fields.");
|
||||||
|
}
|
||||||
|
|
||||||
|
Object value = evaluate(expr.value);
|
||||||
|
((LoxInstance)object).set(expr.name, value);
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitSuperExpr(Expr.Super expr) {
|
||||||
|
int distance = locals.get(expr);
|
||||||
|
LoxClass superclass = (LoxClass)environment.getAt(
|
||||||
|
distance, "super");
|
||||||
|
|
||||||
|
LoxInstance object = (LoxInstance) environment.getAt(
|
||||||
|
distance - 1, "this");
|
||||||
|
|
||||||
|
LoxFunction method = superclass.findMethod(expr.method.lexeme);
|
||||||
|
|
||||||
|
if (method == null) {
|
||||||
|
throw new RuntimeError(expr.method,
|
||||||
|
"Undefined property '" + expr.method.lexeme + "'.");
|
||||||
|
}
|
||||||
|
|
||||||
|
return method.bind(object);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitThisExpr(Expr.This expr) {
|
||||||
|
return lookUpVariable(expr.keyword, expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitUnaryExpr(Expr.Unary expr) {
|
||||||
|
Object right = evaluate(expr.right);
|
||||||
|
|
||||||
|
return switch (expr.operator.type) {
|
||||||
|
case BANG -> !isTruthy(right);
|
||||||
|
case MINUS -> {
|
||||||
|
checkNumberOperand(expr.operator, right);
|
||||||
|
yield -(double) right;
|
||||||
|
}
|
||||||
|
default -> null;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object visitVariableExpr(Expr.Variable expr) {
|
||||||
|
return lookUpVariable(expr.name, expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Object lookUpVariable(Token name, Expr expr) {
|
||||||
|
Integer distance = locals.get(expr);
|
||||||
|
if (distance != null) {
|
||||||
|
return environment.getAt(distance, name.lexeme);
|
||||||
|
} else {
|
||||||
|
return globals.get(name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void checkNumberOperand(Token operator, Object operand) {
|
||||||
|
if (operand instanceof Double) return;
|
||||||
|
throw new RuntimeError(operator, "Operand must be a number.");
|
||||||
|
}
|
||||||
|
|
||||||
|
private void checkNumberOperands(Token operator,
|
||||||
|
Object left, Object right) {
|
||||||
|
if (left instanceof Double && right instanceof Double) return;
|
||||||
|
|
||||||
|
throw new RuntimeError(operator, "Operands must be numbers");
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isTruthy(Object object) {
|
||||||
|
if (object == null) return false;
|
||||||
|
if (object instanceof Boolean) return (Boolean) object;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isEqual(Object a, Object b) {
|
||||||
|
if (a == null && b == null) return true;
|
||||||
|
if (a == null) return false;
|
||||||
|
|
||||||
|
return a.equals(b);
|
||||||
|
}
|
||||||
|
|
||||||
|
private String stringify(Object object) {
|
||||||
|
if (object == null) return "nil";
|
||||||
|
|
||||||
|
if (object instanceof Double) {
|
||||||
|
String text = object.toString();
|
||||||
|
if (text.endsWith(".0")) {
|
||||||
|
text = text.substring(0, text.length() - 2);
|
||||||
|
}
|
||||||
|
return text;
|
||||||
|
}
|
||||||
|
|
||||||
|
return object.toString();
|
||||||
|
}
|
||||||
|
|
||||||
|
private Object evaluate(Expr expr) {
|
||||||
|
return expr.accept(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void execute(Stmt stmt) {
|
||||||
|
stmt.accept(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
void resolve(Expr expr, int depth) {
|
||||||
|
locals.put(expr, depth);
|
||||||
|
}
|
||||||
|
|
||||||
|
void executeBlock(List<Stmt> statements,
|
||||||
|
Environment environment) {
|
||||||
|
Environment previous = this.environment;
|
||||||
|
try {
|
||||||
|
this.environment = environment;
|
||||||
|
|
||||||
|
for (Stmt statement : statements) {
|
||||||
|
execute(statement);
|
||||||
|
}
|
||||||
|
} finally {
|
||||||
|
this.environment = previous;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitBlockStmt(Stmt.Block stmt) {
|
||||||
|
executeBlock(stmt.statements, new Environment(environment));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitClassStmt(Stmt.Class stmt) {
|
||||||
|
Object superclass = null;
|
||||||
|
if (stmt.superclass != null) {
|
||||||
|
superclass = evaluate(stmt.superclass);
|
||||||
|
if (!(superclass instanceof LoxClass)) {
|
||||||
|
throw new RuntimeError(stmt.superclass.name,
|
||||||
|
"Superclass must be a class.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
environment.define(stmt.name.lexeme, null);
|
||||||
|
|
||||||
|
if (stmt.superclass != null) {
|
||||||
|
environment = new Environment(environment);
|
||||||
|
environment.define("super", superclass);
|
||||||
|
}
|
||||||
|
|
||||||
|
Map<String, LoxFunction> methods = new HashMap<>();
|
||||||
|
for (Stmt.Function method : stmt.methods) {
|
||||||
|
LoxFunction function = new LoxFunction(method, environment,
|
||||||
|
method.name.lexeme.equals("init"));
|
||||||
|
methods.put(method.name.lexeme, function);
|
||||||
|
}
|
||||||
|
|
||||||
|
LoxClass klass = new LoxClass(stmt.name.lexeme,
|
||||||
|
(LoxClass)superclass, methods);
|
||||||
|
|
||||||
|
if (superclass != null) {
|
||||||
|
environment = environment.enclosing;
|
||||||
|
}
|
||||||
|
|
||||||
|
environment.assign(stmt.name, klass);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitExpressionStmt(Stmt.Expression stmt) {
|
||||||
|
evaluate(stmt.expression);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitFunctionStmt(Stmt.Function stmt) {
|
||||||
|
LoxFunction function = new LoxFunction(stmt, environment, false);
|
||||||
|
environment.define(stmt.name.lexeme, function);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitIfStmt(Stmt.If stmt) {
|
||||||
|
if (isTruthy(evaluate(stmt.condition))) {
|
||||||
|
execute(stmt.thenBranch);
|
||||||
|
} else if (stmt.elseBranch != null) {
|
||||||
|
execute(stmt.elseBranch);
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitPrintStmt(Stmt.Print stmt) {
|
||||||
|
Object value = evaluate(stmt.expression);
|
||||||
|
System.out.println(stringify(value));
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitReturnStmt(Stmt.Return stmt) {
|
||||||
|
Object value = null;
|
||||||
|
if (stmt.value != null) value = evaluate(stmt.value);
|
||||||
|
|
||||||
|
throw new Return(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitVarStmt(Stmt.Var stmt) {
|
||||||
|
Object value = null;
|
||||||
|
if (stmt.initializer != null) {
|
||||||
|
value = evaluate(stmt.initializer);
|
||||||
|
}
|
||||||
|
|
||||||
|
environment.define(stmt.name.lexeme, value);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitWhileStmt(Stmt.While stmt) {
|
||||||
|
while (isTruthy(evaluate(stmt.condition))) {
|
||||||
|
execute(stmt.body);
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
87
src/lox/Lox.java
Normal file
87
src/lox/Lox.java
Normal file
@ -0,0 +1,87 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.io.BufferedReader;
|
||||||
|
import java.io.IOException;
|
||||||
|
import java.io.InputStreamReader;
|
||||||
|
import java.nio.charset.Charset;
|
||||||
|
import java.nio.file.Files;
|
||||||
|
import java.nio.file.Paths;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
public class Lox {
|
||||||
|
private static final Interpreter interpreter = new Interpreter();
|
||||||
|
static boolean hadError = false;
|
||||||
|
static boolean hadRuntimeError = false;
|
||||||
|
|
||||||
|
public static void main(String[] args) throws IOException {
|
||||||
|
if (args.length > 1) {
|
||||||
|
System.out.println("Usage: jlox [script]");
|
||||||
|
System.exit(64);
|
||||||
|
} else if (args.length == 1) {
|
||||||
|
runFile(args[0]);
|
||||||
|
} else {
|
||||||
|
runPrompt();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void runFile(String path) throws IOException {
|
||||||
|
byte[] bytes = Files.readAllBytes(Paths.get(path));
|
||||||
|
run(new String(bytes, Charset.defaultCharset()));
|
||||||
|
|
||||||
|
if (hadError) System.exit(65);
|
||||||
|
if (hadRuntimeError) System.exit(70);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void runPrompt() throws IOException {
|
||||||
|
InputStreamReader input = new InputStreamReader(System.in);
|
||||||
|
BufferedReader reader = new BufferedReader(input);
|
||||||
|
|
||||||
|
for (; ; ) {
|
||||||
|
System.out.print("> ");
|
||||||
|
String line = reader.readLine();
|
||||||
|
if (line == null) break;
|
||||||
|
run(line);
|
||||||
|
hadError = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void run(String source) {
|
||||||
|
Scanner scanner = new Scanner(source);
|
||||||
|
List<Token> tokens = scanner.scanTokens();
|
||||||
|
|
||||||
|
Parser parser = new Parser(tokens);
|
||||||
|
List<Stmt> statements = parser.parse();
|
||||||
|
|
||||||
|
if (hadError) return;
|
||||||
|
|
||||||
|
Resolver resolver = new Resolver(interpreter);
|
||||||
|
resolver.resolve(statements);
|
||||||
|
|
||||||
|
if (hadError) return;
|
||||||
|
|
||||||
|
interpreter.interpret(statements);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void error(int line, String message) {
|
||||||
|
report(line, "", message);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void runtimeError(RuntimeError error) {
|
||||||
|
System.err.println(error.getMessage() +
|
||||||
|
"\n[line " + error.token.line + "]");
|
||||||
|
hadRuntimeError = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void report(int line, String where, String message) {
|
||||||
|
System.err.println("[line " + line + "] Error" + where + ": " + message);
|
||||||
|
hadError = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void error(Token token, String message) {
|
||||||
|
if (token.type == TokenType.EOF) {
|
||||||
|
report(token.line, " at end", message);
|
||||||
|
} else {
|
||||||
|
report(token.line, " at '" + token.lexeme + "'", message);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
9
src/lox/LoxCallable.java
Normal file
9
src/lox/LoxCallable.java
Normal file
@ -0,0 +1,9 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
interface LoxCallable {
|
||||||
|
int arity();
|
||||||
|
|
||||||
|
Object call(Interpreter interpreter, List<Object> arguments);
|
||||||
|
}
|
51
src/lox/LoxClass.java
Normal file
51
src/lox/LoxClass.java
Normal file
@ -0,0 +1,51 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
public class LoxClass implements LoxCallable {
|
||||||
|
final String name;
|
||||||
|
final LoxClass superclass;
|
||||||
|
private final Map<String, LoxFunction> methods;
|
||||||
|
|
||||||
|
public LoxClass(String name, LoxClass superclass,
|
||||||
|
Map<String, LoxFunction> methods) {
|
||||||
|
this.name = name;
|
||||||
|
this.superclass = superclass;
|
||||||
|
this.methods = methods;
|
||||||
|
}
|
||||||
|
|
||||||
|
LoxFunction findMethod(String name) {
|
||||||
|
if (methods.containsKey(name)) {
|
||||||
|
return methods.get(name);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (superclass != null) {
|
||||||
|
return superclass.findMethod(name);
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String toString() {
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int arity() {
|
||||||
|
LoxFunction initializer = findMethod("init");
|
||||||
|
if (initializer == null) return 0;
|
||||||
|
return initializer.arity();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object call(Interpreter interpreter, List<Object> arguments) {
|
||||||
|
LoxInstance instance = new LoxInstance(this);
|
||||||
|
LoxFunction initializer = findMethod("init");
|
||||||
|
if (initializer != null) {
|
||||||
|
initializer.bind(instance).call(interpreter, arguments);
|
||||||
|
}
|
||||||
|
return instance;
|
||||||
|
}
|
||||||
|
}
|
53
src/lox/LoxFunction.java
Normal file
53
src/lox/LoxFunction.java
Normal file
@ -0,0 +1,53 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
public class LoxFunction implements LoxCallable {
|
||||||
|
private final Stmt.Function declaration;
|
||||||
|
private final Environment closure;
|
||||||
|
|
||||||
|
private final boolean isInitializer;
|
||||||
|
|
||||||
|
LoxFunction(Stmt.Function declaration, Environment closure, boolean isInitializer) {
|
||||||
|
this.closure = closure;
|
||||||
|
this.declaration = declaration;
|
||||||
|
this.isInitializer = isInitializer;
|
||||||
|
}
|
||||||
|
|
||||||
|
LoxFunction bind(LoxInstance instance) {
|
||||||
|
Environment environment = new Environment(closure);
|
||||||
|
environment.define("this", instance);
|
||||||
|
return new LoxFunction(declaration, environment,
|
||||||
|
isInitializer);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int arity() {
|
||||||
|
return declaration.params.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Object call(Interpreter interpreter, List<Object> arguments) {
|
||||||
|
Environment environment = new Environment(closure);
|
||||||
|
for (int i = 0; i < declaration.params.size(); i++) {
|
||||||
|
environment.define(declaration.params.get(i).lexeme,
|
||||||
|
arguments.get(i));
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
interpreter.executeBlock(declaration.body, environment);
|
||||||
|
} catch (Return returnValue) {
|
||||||
|
if (isInitializer) return closure.getAt(0, "this");
|
||||||
|
|
||||||
|
return returnValue.value;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isInitializer) return closure.getAt(0, "this");
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String toString() {
|
||||||
|
return "<fn " + declaration.name.lexeme + ">";
|
||||||
|
}
|
||||||
|
}
|
34
src/lox/LoxInstance.java
Normal file
34
src/lox/LoxInstance.java
Normal file
@ -0,0 +1,34 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
public class LoxInstance {
|
||||||
|
private LoxClass klass;
|
||||||
|
private final Map<String, Object> fields = new HashMap<>();
|
||||||
|
|
||||||
|
LoxInstance(LoxClass klass) {
|
||||||
|
this.klass = klass;
|
||||||
|
}
|
||||||
|
|
||||||
|
Object get(Token name) {
|
||||||
|
if (fields.containsKey(name.lexeme)) {
|
||||||
|
return fields.get(name.lexeme);
|
||||||
|
}
|
||||||
|
|
||||||
|
LoxFunction method = klass.findMethod(name.lexeme);
|
||||||
|
if (method != null) return method.bind(this);
|
||||||
|
|
||||||
|
throw new RuntimeError(name,
|
||||||
|
"Undefined property '" + name.lexeme + "'.");
|
||||||
|
}
|
||||||
|
|
||||||
|
void set(Token name, Object value) {
|
||||||
|
fields.put(name.lexeme, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public String toString() {
|
||||||
|
return klass.name + " instance";
|
||||||
|
}
|
||||||
|
}
|
444
src/lox/Parser.java
Normal file
444
src/lox/Parser.java
Normal file
@ -0,0 +1,444 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
import static lox.TokenType.*;
|
||||||
|
|
||||||
|
public class Parser {
|
||||||
|
private static class ParseError extends RuntimeException {
|
||||||
|
}
|
||||||
|
|
||||||
|
private final List<Token> tokens;
|
||||||
|
private int current;
|
||||||
|
|
||||||
|
Parser(List<Token> tokens) {
|
||||||
|
this.tokens = tokens;
|
||||||
|
}
|
||||||
|
|
||||||
|
List<Stmt> parse() {
|
||||||
|
List<Stmt> statements = new ArrayList<>();
|
||||||
|
while (!isAtEnd()) {
|
||||||
|
statements.add(declaration());
|
||||||
|
}
|
||||||
|
|
||||||
|
return statements;
|
||||||
|
}
|
||||||
|
|
||||||
|
private Expr expression() {
|
||||||
|
return assignment();
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt declaration() {
|
||||||
|
try {
|
||||||
|
if (match(CLASS)) return classDeclaration();
|
||||||
|
if (match(FUN)) return function("function");
|
||||||
|
if (match(VAR)) return varDeclaration();
|
||||||
|
|
||||||
|
return statement();
|
||||||
|
} catch (ParseError error) {
|
||||||
|
synchronize();
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt classDeclaration() {
|
||||||
|
Token name = consume(IDENTIFIER, "Expect class name.");
|
||||||
|
|
||||||
|
Expr.Variable superclass = null;
|
||||||
|
if (match(LESS)) {
|
||||||
|
consume(IDENTIFIER, "Expect superclass name.");
|
||||||
|
superclass = new Expr.Variable(previous());
|
||||||
|
}
|
||||||
|
|
||||||
|
consume(LEFT_BRACE, "Expect '{' before class body.");
|
||||||
|
|
||||||
|
List<Stmt.Function> methods = new ArrayList<>();
|
||||||
|
while (!check(RIGHT_BRACE) && !isAtEnd()) {
|
||||||
|
methods.add(function("method"));
|
||||||
|
}
|
||||||
|
|
||||||
|
consume(RIGHT_BRACE, "Expect '}' after class body.");
|
||||||
|
|
||||||
|
return new Stmt.Class(name, superclass, methods);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt statement() {
|
||||||
|
if (match(FOR)) return forStatement();
|
||||||
|
if (match(IF)) return ifStatement();
|
||||||
|
if (match(PRINT)) return printStatement();
|
||||||
|
if (match(RETURN)) return returnStatement();
|
||||||
|
if (match(WHILE)) return whileStatement();
|
||||||
|
if (match(LEFT_BRACE)) return new Stmt.Block(block());
|
||||||
|
|
||||||
|
return expressionStatement();
|
||||||
|
}
|
||||||
|
|
||||||
|
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) {
|
||||||
|
body = new Stmt.Block(
|
||||||
|
Arrays.asList(
|
||||||
|
body,
|
||||||
|
new Stmt.Expression(increment)));
|
||||||
|
}
|
||||||
|
|
||||||
|
if (condition == null) condition = new Expr.Literal(true);
|
||||||
|
body = new Stmt.While(condition, body);
|
||||||
|
|
||||||
|
if (initializer != null) {
|
||||||
|
body = new Stmt.Block(Arrays.asList(initializer, body));
|
||||||
|
}
|
||||||
|
|
||||||
|
return body;
|
||||||
|
}
|
||||||
|
|
||||||
|
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 printStatement() {
|
||||||
|
Expr value = expression();
|
||||||
|
consume(SEMICOLON, "Expect ';' after value.");
|
||||||
|
return new Stmt.Print(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt varDeclaration() {
|
||||||
|
Token name = consume(IDENTIFIER, "Expect variable name.");
|
||||||
|
|
||||||
|
Expr initializer = null;
|
||||||
|
if (match(EQUAL)) {
|
||||||
|
initializer = expression();
|
||||||
|
}
|
||||||
|
|
||||||
|
consume(SEMICOLON, "Expect ';' after variable declaration.");
|
||||||
|
return new Stmt.Var(name, initializer);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt whileStatement() {
|
||||||
|
consume(LEFT_PAREN, "Expect '(' after 'while'.");
|
||||||
|
Expr condition = expression();
|
||||||
|
consume(RIGHT_PAREN, "Expect ')' after condition.");
|
||||||
|
Stmt body = statement();
|
||||||
|
|
||||||
|
return new Stmt.While(condition, body);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt expressionStatement() {
|
||||||
|
Expr expr = expression();
|
||||||
|
consume(SEMICOLON, "Expect ';' after expression.");
|
||||||
|
return new Stmt.Expression(expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Stmt.Function 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);
|
||||||
|
}
|
||||||
|
|
||||||
|
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() {
|
||||||
|
Expr expr = or();
|
||||||
|
|
||||||
|
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);
|
||||||
|
} else if (expr instanceof Expr.Get get) {
|
||||||
|
return new Expr.Set(get.object, get.name, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw error(equals, "Invalid assignment target.");
|
||||||
|
}
|
||||||
|
|
||||||
|
return expr;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
|
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(MINUS, PLUS)) {
|
||||||
|
Token operator = previous();
|
||||||
|
Expr right = factor();
|
||||||
|
expr = new Expr.Binary(expr, operator, right);
|
||||||
|
}
|
||||||
|
|
||||||
|
return expr;
|
||||||
|
}
|
||||||
|
|
||||||
|
private Expr factor() {
|
||||||
|
Expr expr = unary();
|
||||||
|
|
||||||
|
while (match(SLASH, STAR)) {
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
return call();
|
||||||
|
}
|
||||||
|
|
||||||
|
private Expr finishCall(Expr callee) {
|
||||||
|
List<Expr> arguments = new ArrayList<>();
|
||||||
|
if (!check(RIGHT_PAREN)) {
|
||||||
|
do {
|
||||||
|
if (arguments.size() >= 255) {
|
||||||
|
error(peek(), "Can't have more than 255 arguments.");
|
||||||
|
}
|
||||||
|
arguments.add(expression());
|
||||||
|
} while (match(COMMA));
|
||||||
|
}
|
||||||
|
|
||||||
|
Token paren = consume(RIGHT_PAREN,
|
||||||
|
"Expect ')' after arguments.");
|
||||||
|
|
||||||
|
return new Expr.Call(callee, paren, arguments);
|
||||||
|
}
|
||||||
|
|
||||||
|
private Expr call() {
|
||||||
|
Expr expr = primary();
|
||||||
|
|
||||||
|
while (true) {
|
||||||
|
if (match(LEFT_PAREN)) {
|
||||||
|
expr = finishCall(expr);
|
||||||
|
} else if (match(DOT)) {
|
||||||
|
Token name = consume(IDENTIFIER,
|
||||||
|
"Expect property name after '.'.");
|
||||||
|
expr = new Expr.Get(expr, name);
|
||||||
|
} else {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return expr;
|
||||||
|
}
|
||||||
|
|
||||||
|
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(SUPER)) {
|
||||||
|
Token keyword = previous();
|
||||||
|
consume(DOT, "Expect '.' after 'super'.");
|
||||||
|
Token method = consume(IDENTIFIER,
|
||||||
|
"Expect superclass method name.");
|
||||||
|
return new Expr.Super(keyword, method);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (match(THIS)) return new Expr.This(previous());
|
||||||
|
|
||||||
|
if (match(IDENTIFIER)) {
|
||||||
|
return new Expr.Variable(previous());
|
||||||
|
}
|
||||||
|
|
||||||
|
if (match(LEFT_PAREN)) {
|
||||||
|
Expr expr = expression();
|
||||||
|
consume(RIGHT_PAREN, "Expect ')' after expression.");
|
||||||
|
return new Expr.Grouping(expr);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw error(peek(), "Expect 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 void synchronize() {
|
||||||
|
advance();
|
||||||
|
|
||||||
|
while (!isAtEnd()) {
|
||||||
|
if (previous().type == SEMICOLON) return;
|
||||||
|
|
||||||
|
switch (peek().type) {
|
||||||
|
case CLASS:
|
||||||
|
case FUN:
|
||||||
|
case VAR:
|
||||||
|
case FOR:
|
||||||
|
case IF:
|
||||||
|
case WHILE:
|
||||||
|
case PRINT:
|
||||||
|
case RETURN:
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
advance();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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();
|
||||||
|
}
|
||||||
|
}
|
304
src/lox/Resolver.java
Normal file
304
src/lox/Resolver.java
Normal file
@ -0,0 +1,304 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
import java.util.Stack;
|
||||||
|
|
||||||
|
public class Resolver implements Expr.Visitor<Void>, Stmt.Visitor<Void> {
|
||||||
|
private final Interpreter interpreter;
|
||||||
|
private final Stack<Map<String, Boolean>> scopes = new Stack<>();
|
||||||
|
private FunctionType currentFunction = FunctionType.NONE;
|
||||||
|
|
||||||
|
Resolver(Interpreter interpreter) {
|
||||||
|
this.interpreter = interpreter;
|
||||||
|
}
|
||||||
|
|
||||||
|
private enum FunctionType {
|
||||||
|
NONE,
|
||||||
|
FUNCTION,
|
||||||
|
INITIALIZER,
|
||||||
|
METHOD
|
||||||
|
}
|
||||||
|
|
||||||
|
private enum ClassType {
|
||||||
|
NONE,
|
||||||
|
CLASS,
|
||||||
|
SUBCLASS
|
||||||
|
}
|
||||||
|
|
||||||
|
private ClassType currentClass = ClassType.NONE;
|
||||||
|
|
||||||
|
void resolve(List<Stmt> statements) {
|
||||||
|
for (Stmt statement : statements) {
|
||||||
|
resolve(statement);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitAssignExpr(Expr.Assign expr) {
|
||||||
|
resolve(expr.value);
|
||||||
|
resolveLocal(expr, expr.name);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitBinaryExpr(Expr.Binary expr) {
|
||||||
|
resolve(expr.left);
|
||||||
|
resolve(expr.right);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitCallExpr(Expr.Call expr) {
|
||||||
|
resolve(expr.callee);
|
||||||
|
|
||||||
|
for (Expr argument : expr.arguments) {
|
||||||
|
resolve(argument);
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitGetExpr(Expr.Get expr) {
|
||||||
|
resolve(expr.object);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitGroupingExpr(Expr.Grouping expr) {
|
||||||
|
resolve(expr.expression);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitLiteralExpr(Expr.Literal expr) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitLogicalExpr(Expr.Logical expr) {
|
||||||
|
resolve(expr.left);
|
||||||
|
resolve(expr.right);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitSetExpr(Expr.Set expr) {
|
||||||
|
resolve(expr.value);
|
||||||
|
resolve(expr.object);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitSuperExpr(Expr.Super expr) {
|
||||||
|
if (currentClass == ClassType.NONE) {
|
||||||
|
Lox.error(expr.keyword,
|
||||||
|
"Can't use 'super' outside of a class.");
|
||||||
|
} else if (currentClass != ClassType.SUBCLASS) {
|
||||||
|
Lox.error(expr.keyword,
|
||||||
|
"Can't use 'super' in a class with no superclass.");
|
||||||
|
}
|
||||||
|
|
||||||
|
resolveLocal(expr, expr.keyword);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitThisExpr(Expr.This expr) {
|
||||||
|
if (currentClass == ClassType.NONE) {
|
||||||
|
Lox.error(expr.keyword,
|
||||||
|
"Can't use 'this' outside of a class.");
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
resolveLocal(expr, expr.keyword);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitUnaryExpr(Expr.Unary expr) {
|
||||||
|
resolve(expr.right);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitVariableExpr(Expr.Variable expr) {
|
||||||
|
if (!scopes.isEmpty() &&
|
||||||
|
scopes.peek().get(expr.name.lexeme) == Boolean.FALSE) {
|
||||||
|
Lox.error(expr.name,
|
||||||
|
"Can't read local variable in its own initializer.");
|
||||||
|
}
|
||||||
|
|
||||||
|
resolveLocal(expr, expr.name);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitBlockStmt(Stmt.Block stmt) {
|
||||||
|
beginScope();
|
||||||
|
resolve(stmt.statements);
|
||||||
|
endScope();
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitClassStmt(Stmt.Class stmt) {
|
||||||
|
ClassType enclosingClass = currentClass;
|
||||||
|
currentClass = ClassType.CLASS;
|
||||||
|
|
||||||
|
declare(stmt.name);
|
||||||
|
define(stmt.name);
|
||||||
|
|
||||||
|
if (stmt.superclass != null &&
|
||||||
|
stmt.name.lexeme.equals(stmt.superclass.name.lexeme)) {
|
||||||
|
Lox.error(stmt.superclass.name,
|
||||||
|
"A class can't inherit from itself.");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stmt.superclass != null) {
|
||||||
|
currentClass = ClassType.SUBCLASS;
|
||||||
|
resolve(stmt.superclass);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stmt.superclass != null) {
|
||||||
|
beginScope();
|
||||||
|
scopes.peek().put("super", true);
|
||||||
|
}
|
||||||
|
|
||||||
|
beginScope();
|
||||||
|
scopes.peek().put("this", true);
|
||||||
|
|
||||||
|
for (Stmt.Function method : stmt.methods) {
|
||||||
|
FunctionType declaration = FunctionType.METHOD;
|
||||||
|
if (method.name.lexeme.equals("init")) {
|
||||||
|
declaration = FunctionType.INITIALIZER;
|
||||||
|
}
|
||||||
|
resolveFunction(method, declaration);
|
||||||
|
}
|
||||||
|
|
||||||
|
endScope();
|
||||||
|
|
||||||
|
if (stmt.superclass != null) endScope();
|
||||||
|
|
||||||
|
currentClass = enclosingClass;
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resolve(Stmt stmt) {
|
||||||
|
stmt.accept(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resolve(Expr expr) {
|
||||||
|
expr.accept(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resolveFunction(Stmt.Function function, FunctionType type) {
|
||||||
|
FunctionType enclosingFunction = currentFunction;
|
||||||
|
currentFunction = type;
|
||||||
|
|
||||||
|
beginScope();
|
||||||
|
for (Token param : function.params) {
|
||||||
|
declare(param);
|
||||||
|
define(param);
|
||||||
|
}
|
||||||
|
resolve(function.body);
|
||||||
|
endScope();
|
||||||
|
currentFunction = enclosingFunction;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void beginScope() {
|
||||||
|
scopes.push(new HashMap<>());
|
||||||
|
}
|
||||||
|
|
||||||
|
private void endScope() {
|
||||||
|
scopes.pop();
|
||||||
|
}
|
||||||
|
|
||||||
|
private void declare(Token name) {
|
||||||
|
if (scopes.isEmpty()) return;
|
||||||
|
|
||||||
|
Map<String, Boolean> scope = scopes.peek();
|
||||||
|
if (scope.containsKey(name.lexeme)) {
|
||||||
|
Lox.error(name,
|
||||||
|
"Already a variable with this name in this scope.");
|
||||||
|
}
|
||||||
|
scope.put(name.lexeme, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void define(Token name) {
|
||||||
|
if (scopes.isEmpty()) return;
|
||||||
|
scopes.peek().put(name.lexeme, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void resolveLocal(Expr expr, Token name) {
|
||||||
|
for (int i = scopes.size() - 1; i >= 0; i--) {
|
||||||
|
if (scopes.get(i).containsKey(name.lexeme)) {
|
||||||
|
interpreter.resolve(expr, scopes.size() - 1 - i);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitExpressionStmt(Stmt.Expression stmt) {
|
||||||
|
resolve(stmt.expression);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitFunctionStmt(Stmt.Function stmt) {
|
||||||
|
declare(stmt.name);
|
||||||
|
define(stmt.name);
|
||||||
|
|
||||||
|
resolveFunction(stmt, FunctionType.FUNCTION);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitIfStmt(Stmt.If stmt) {
|
||||||
|
resolve(stmt.condition);
|
||||||
|
resolve(stmt.thenBranch);
|
||||||
|
if (stmt.elseBranch != null) resolve(stmt.elseBranch);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitPrintStmt(Stmt.Print stmt) {
|
||||||
|
resolve(stmt.expression);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitReturnStmt(Stmt.Return stmt) {
|
||||||
|
if (currentFunction == FunctionType.NONE) {
|
||||||
|
Lox.error(stmt.keyword, "Can't return from top-level code.");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stmt.value != null) {
|
||||||
|
if (currentFunction == FunctionType.INITIALIZER) {
|
||||||
|
Lox.error(stmt.keyword,
|
||||||
|
"Can't return a value from an initializer.");
|
||||||
|
}
|
||||||
|
resolve(stmt.value);
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitVarStmt(Stmt.Var stmt) {
|
||||||
|
declare(stmt.name);
|
||||||
|
if (stmt.initializer != null) {
|
||||||
|
resolve(stmt.initializer);
|
||||||
|
}
|
||||||
|
define(stmt.name);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public Void visitWhileStmt(Stmt.While stmt) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
10
src/lox/Return.java
Normal file
10
src/lox/Return.java
Normal file
@ -0,0 +1,10 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
public class Return extends RuntimeException {
|
||||||
|
final Object value;
|
||||||
|
|
||||||
|
Return(Object value) {
|
||||||
|
super(null, null, false, false);
|
||||||
|
this.value = value;
|
||||||
|
}
|
||||||
|
}
|
10
src/lox/RuntimeError.java
Normal file
10
src/lox/RuntimeError.java
Normal file
@ -0,0 +1,10 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
public class RuntimeError extends RuntimeException {
|
||||||
|
final Token token;
|
||||||
|
|
||||||
|
RuntimeError(Token token, String message) {
|
||||||
|
super(message);
|
||||||
|
this.token = token;
|
||||||
|
}
|
||||||
|
}
|
218
src/lox/Scanner.java
Normal file
218
src/lox/Scanner.java
Normal file
@ -0,0 +1,218 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
import static lox.TokenType.*;
|
||||||
|
|
||||||
|
public class Scanner {
|
||||||
|
private final String source;
|
||||||
|
private final List<Token> tokens = new ArrayList<>();
|
||||||
|
private int start = 0;
|
||||||
|
private int current = 0;
|
||||||
|
private int line = 1;
|
||||||
|
|
||||||
|
private static final Map<String, TokenType> keywords;
|
||||||
|
|
||||||
|
static {
|
||||||
|
keywords = new HashMap<>();
|
||||||
|
keywords.put("and", AND);
|
||||||
|
keywords.put("class", CLASS);
|
||||||
|
keywords.put("else", ELSE);
|
||||||
|
keywords.put("false", FALSE);
|
||||||
|
keywords.put("for", FOR);
|
||||||
|
keywords.put("fun", FUN);
|
||||||
|
keywords.put("if", IF);
|
||||||
|
keywords.put("nil", NIL);
|
||||||
|
keywords.put("or", OR);
|
||||||
|
keywords.put("print", PRINT);
|
||||||
|
keywords.put("return", RETURN);
|
||||||
|
keywords.put("super", SUPER);
|
||||||
|
keywords.put("this", THIS);
|
||||||
|
keywords.put("true", TRUE);
|
||||||
|
keywords.put("var", VAR);
|
||||||
|
keywords.put("while", WHILE);
|
||||||
|
}
|
||||||
|
|
||||||
|
Scanner(String source) {
|
||||||
|
this.source = source;
|
||||||
|
}
|
||||||
|
|
||||||
|
List<Token> scanTokens() {
|
||||||
|
while (!isAtEnd()) {
|
||||||
|
start = current;
|
||||||
|
scanToken();
|
||||||
|
}
|
||||||
|
|
||||||
|
tokens.add(new Token(EOF, "", null, line));
|
||||||
|
return tokens;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void scanToken() {
|
||||||
|
char c = advance();
|
||||||
|
switch (c) {
|
||||||
|
case '(':
|
||||||
|
addToken(LEFT_PAREN);
|
||||||
|
break;
|
||||||
|
case ')':
|
||||||
|
addToken(RIGHT_PAREN);
|
||||||
|
break;
|
||||||
|
case '{':
|
||||||
|
addToken(LEFT_BRACE);
|
||||||
|
break;
|
||||||
|
case '}':
|
||||||
|
addToken(RIGHT_BRACE);
|
||||||
|
break;
|
||||||
|
case ',':
|
||||||
|
addToken(COMMA);
|
||||||
|
break;
|
||||||
|
case '.':
|
||||||
|
addToken(DOT);
|
||||||
|
break;
|
||||||
|
case '-':
|
||||||
|
addToken(MINUS);
|
||||||
|
break;
|
||||||
|
case '+':
|
||||||
|
addToken(PLUS);
|
||||||
|
break;
|
||||||
|
case ';':
|
||||||
|
addToken(SEMICOLON);
|
||||||
|
break;
|
||||||
|
case '*':
|
||||||
|
addToken(STAR);
|
||||||
|
break;
|
||||||
|
case '!':
|
||||||
|
addToken(match('=') ? BANG_EQUAL : BANG);
|
||||||
|
break;
|
||||||
|
case '=':
|
||||||
|
addToken(match('=') ? EQUAL_EQUAL : EQUAL);
|
||||||
|
break;
|
||||||
|
case '<':
|
||||||
|
addToken(match('=') ? LESS_EQUAL : LESS);
|
||||||
|
break;
|
||||||
|
case '>':
|
||||||
|
addToken(match('=') ? GREATER_EQUAL : GREATER);
|
||||||
|
break;
|
||||||
|
case '/':
|
||||||
|
if (match('/')) {
|
||||||
|
while (peek() != '\n' && !isAtEnd()) advance();
|
||||||
|
} else {
|
||||||
|
addToken(SLASH);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case ' ':
|
||||||
|
case '\r':
|
||||||
|
case '\t':
|
||||||
|
break;
|
||||||
|
|
||||||
|
case '\n':
|
||||||
|
line++;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case '"':
|
||||||
|
string();
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
if (isDigit(c)) {
|
||||||
|
number();
|
||||||
|
} else if (isAlpha(c)) {
|
||||||
|
identifier();
|
||||||
|
} else {
|
||||||
|
Lox.error(line, "Unexpected character.");
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void identifier() {
|
||||||
|
while (isAlphaNumeric(peek())) advance();
|
||||||
|
|
||||||
|
String text = source.substring(start, current);
|
||||||
|
TokenType type = keywords.get(text);
|
||||||
|
if (type == null) type = IDENTIFIER;
|
||||||
|
addToken(type);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void number() {
|
||||||
|
while (isDigit(peek())) advance();
|
||||||
|
|
||||||
|
if (peek() == '.' && isDigit(peekNext())) {
|
||||||
|
|
||||||
|
do advance();
|
||||||
|
while (isDigit(peek()));
|
||||||
|
}
|
||||||
|
|
||||||
|
addToken(NUMBER,
|
||||||
|
Double.parseDouble(source.substring(start, current)));
|
||||||
|
}
|
||||||
|
|
||||||
|
private void string() {
|
||||||
|
while (peek() != '"' && !isAtEnd()) {
|
||||||
|
if (peek() == '\n') line++;
|
||||||
|
advance();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isAtEnd()) {
|
||||||
|
Lox.error(line, "Unterminated string.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
advance();
|
||||||
|
|
||||||
|
String value = source.substring(start + 1, current - 1);
|
||||||
|
addToken(STRING, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean match(char expected) {
|
||||||
|
if (isAtEnd()) return false;
|
||||||
|
if (source.charAt(current) != expected) return false;
|
||||||
|
|
||||||
|
current++;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
private char peek() {
|
||||||
|
if (isAtEnd()) return '\0';
|
||||||
|
return source.charAt(current);
|
||||||
|
}
|
||||||
|
|
||||||
|
private char peekNext() {
|
||||||
|
if (current + 1 >= source.length()) return '\0';
|
||||||
|
return source.charAt(current + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isAlpha(char c) {
|
||||||
|
return (c >= 'a' && c <= 'z') ||
|
||||||
|
(c >= 'A' && c <= 'Z') ||
|
||||||
|
c == '_';
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isAlphaNumeric(char c) {
|
||||||
|
return isAlpha(c) || isDigit(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isDigit(char c) {
|
||||||
|
return c >= '0' && c <= '9';
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isAtEnd() {
|
||||||
|
return current >= source.length();
|
||||||
|
}
|
||||||
|
|
||||||
|
private char advance() {
|
||||||
|
return source.charAt(current++);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void addToken(TokenType type) {
|
||||||
|
addToken(type, null);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void addToken(TokenType type, Object literal) {
|
||||||
|
String text = source.substring(start, current);
|
||||||
|
tokens.add(new Token(type, text, literal, line));
|
||||||
|
}
|
||||||
|
}
|
145
src/lox/Stmt.java
Normal file
145
src/lox/Stmt.java
Normal file
@ -0,0 +1,145 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
abstract class Stmt {
|
||||||
|
interface Visitor<R> {
|
||||||
|
R visitBlockStmt(Block stmt);
|
||||||
|
R visitClassStmt(Class stmt);
|
||||||
|
R visitExpressionStmt(Expression stmt);
|
||||||
|
R visitFunctionStmt(Function stmt);
|
||||||
|
R visitIfStmt(If stmt);
|
||||||
|
R visitPrintStmt(Print stmt);
|
||||||
|
R visitReturnStmt(Return stmt);
|
||||||
|
R visitVarStmt(Var stmt);
|
||||||
|
R visitWhileStmt(While stmt);
|
||||||
|
}
|
||||||
|
static class Block extends Stmt {
|
||||||
|
Block(List<Stmt> statements) {
|
||||||
|
this.statements = statements;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitBlockStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final List<Stmt> statements;
|
||||||
|
}
|
||||||
|
static class Class extends Stmt {
|
||||||
|
Class(Token name, Expr.Variable superclass, List<Stmt.Function> methods) {
|
||||||
|
this.name = name;
|
||||||
|
this.superclass = superclass;
|
||||||
|
this.methods = methods;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitClassStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token name;
|
||||||
|
final Expr.Variable superclass;
|
||||||
|
final List<Stmt.Function> methods;
|
||||||
|
}
|
||||||
|
static class Expression extends Stmt {
|
||||||
|
Expression(Expr expression) {
|
||||||
|
this.expression = expression;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitExpressionStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr expression;
|
||||||
|
}
|
||||||
|
static class Function extends Stmt {
|
||||||
|
Function(Token name, List<Token> params, List<Stmt> body) {
|
||||||
|
this.name = name;
|
||||||
|
this.params = params;
|
||||||
|
this.body = body;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitFunctionStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token name;
|
||||||
|
final List<Token> params;
|
||||||
|
final List<Stmt> body;
|
||||||
|
}
|
||||||
|
static class If extends Stmt {
|
||||||
|
If(Expr condition, Stmt thenBranch, Stmt elseBranch) {
|
||||||
|
this.condition = condition;
|
||||||
|
this.thenBranch = thenBranch;
|
||||||
|
this.elseBranch = elseBranch;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitIfStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr condition;
|
||||||
|
final Stmt thenBranch;
|
||||||
|
final Stmt elseBranch;
|
||||||
|
}
|
||||||
|
static class Print extends Stmt {
|
||||||
|
Print(Expr expression) {
|
||||||
|
this.expression = expression;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitPrintStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr expression;
|
||||||
|
}
|
||||||
|
static class Return extends Stmt {
|
||||||
|
Return(Token keyword, Expr value) {
|
||||||
|
this.keyword = keyword;
|
||||||
|
this.value = value;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitReturnStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token keyword;
|
||||||
|
final Expr value;
|
||||||
|
}
|
||||||
|
static class Var extends Stmt {
|
||||||
|
Var(Token name, Expr initializer) {
|
||||||
|
this.name = name;
|
||||||
|
this.initializer = initializer;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitVarStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Token name;
|
||||||
|
final Expr initializer;
|
||||||
|
}
|
||||||
|
static class While extends Stmt {
|
||||||
|
While(Expr condition, Stmt body) {
|
||||||
|
this.condition = condition;
|
||||||
|
this.body = body;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
<R> R accept(Visitor<R> visitor) {
|
||||||
|
return visitor.visitWhileStmt(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
final Expr condition;
|
||||||
|
final Stmt body;
|
||||||
|
}
|
||||||
|
|
||||||
|
abstract <R> R accept(Visitor<R> visitor);
|
||||||
|
}
|
19
src/lox/Token.java
Normal file
19
src/lox/Token.java
Normal file
@ -0,0 +1,19 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
public class Token {
|
||||||
|
final TokenType type;
|
||||||
|
final String lexeme;
|
||||||
|
final Object literal;
|
||||||
|
final int line;
|
||||||
|
|
||||||
|
Token(TokenType type, String lexeme, Object literal, int line) {
|
||||||
|
this.type = type;
|
||||||
|
this.lexeme = lexeme;
|
||||||
|
this.literal = literal;
|
||||||
|
this.line = line;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
return type + " " + lexeme + " " + literal;
|
||||||
|
}
|
||||||
|
}
|
18
src/lox/TokenType.java
Normal file
18
src/lox/TokenType.java
Normal file
@ -0,0 +1,18 @@
|
|||||||
|
package lox;
|
||||||
|
|
||||||
|
public enum TokenType {
|
||||||
|
LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE,
|
||||||
|
COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR,
|
||||||
|
|
||||||
|
BANG, BANG_EQUAL,
|
||||||
|
EQUAL, EQUAL_EQUAL,
|
||||||
|
GREATER, GREATER_EQUAL,
|
||||||
|
LESS, LESS_EQUAL,
|
||||||
|
|
||||||
|
IDENTIFIER, STRING, NUMBER,
|
||||||
|
|
||||||
|
AND, CLASS, ELSE, FALSE, FUN, FOR, IF, NIL, OR,
|
||||||
|
PRINT, RETURN, SUPER, THIS, TRUE, VAR, WHILE,
|
||||||
|
|
||||||
|
EOF
|
||||||
|
}
|
119
src/tool/GenerateAst.java
Normal file
119
src/tool/GenerateAst.java
Normal file
@ -0,0 +1,119 @@
|
|||||||
|
package tool;
|
||||||
|
|
||||||
|
import java.io.IOException;
|
||||||
|
import java.io.PrintWriter;
|
||||||
|
import java.nio.charset.StandardCharsets;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
public class GenerateAst {
|
||||||
|
public static void main(String[] args) throws IOException {
|
||||||
|
if (args.length != 1) {
|
||||||
|
System.err.println("Usage: generate_ast <output directory>");
|
||||||
|
System.exit(64);
|
||||||
|
}
|
||||||
|
String outputDir = args[0];
|
||||||
|
defineAst(outputDir, "Expr", Arrays.asList(
|
||||||
|
"Assign : Token name, Expr value",
|
||||||
|
"Binary : Expr left, Token operator, Expr right",
|
||||||
|
"Call : Expr callee, Token paren, List<Expr> arguments",
|
||||||
|
"Get : Expr object, Token name",
|
||||||
|
"Grouping : Expr expression",
|
||||||
|
"Literal : Object value",
|
||||||
|
"Logical : Expr left, Token operator, Expr right",
|
||||||
|
"Set : Expr object, Token name, Expr value",
|
||||||
|
"Super : Token keyword, Token method",
|
||||||
|
"This : Token keyword",
|
||||||
|
"Unary : Token operator, Expr right",
|
||||||
|
"Variable : Token name"
|
||||||
|
));
|
||||||
|
|
||||||
|
defineAst(outputDir, "Stmt", Arrays.asList(
|
||||||
|
"Block : List<Stmt> statements",
|
||||||
|
"Class : Token name, Expr.Variable superclass," +
|
||||||
|
" List<Stmt.Function> methods",
|
||||||
|
"Expression : Expr expression",
|
||||||
|
"Function : Token name, List<Token> params," +
|
||||||
|
" List<Stmt> body",
|
||||||
|
"If : Expr condition, Stmt thenBranch," +
|
||||||
|
" Stmt elseBranch",
|
||||||
|
"Print : Expr expression",
|
||||||
|
"Return : Token keyword, Expr value",
|
||||||
|
"Var : Token name, Expr initializer",
|
||||||
|
"While : Expr condition, Stmt body"
|
||||||
|
));
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void defineAst(
|
||||||
|
String outputDir, String baseName, List<String> types) throws IOException {
|
||||||
|
String path = outputDir + "/" + baseName + ".java";
|
||||||
|
PrintWriter writer = new PrintWriter(path, StandardCharsets.UTF_8);
|
||||||
|
|
||||||
|
writer.println("package lox;");
|
||||||
|
writer.println();
|
||||||
|
writer.println("import java.util.List;");
|
||||||
|
writer.println();
|
||||||
|
writer.println("abstract class " + baseName + " {");
|
||||||
|
|
||||||
|
defineVisitor(writer, baseName, types);
|
||||||
|
|
||||||
|
|
||||||
|
for (String type : types) {
|
||||||
|
String className = type.split(":")[0].trim();
|
||||||
|
String fields = type.split(":")[1].trim();
|
||||||
|
defineType(writer, baseName, className, fields);
|
||||||
|
}
|
||||||
|
|
||||||
|
writer.println();
|
||||||
|
writer.println("\tabstract <R> R accept(Visitor<R> visitor);");
|
||||||
|
|
||||||
|
writer.println("}");
|
||||||
|
writer.close();
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void defineVisitor(
|
||||||
|
PrintWriter writer, String baseName, List<String> types) {
|
||||||
|
writer.println("\tinterface Visitor<R> {");
|
||||||
|
|
||||||
|
for (String type : types) {
|
||||||
|
String typeName = type.split(":")[0].trim();
|
||||||
|
writer.println("\t\tR visit" + typeName + baseName + "(" +
|
||||||
|
typeName + " " + baseName.toLowerCase() + ");");
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
writer.println("\t}");
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void defineType(
|
||||||
|
PrintWriter writer, String baseName,
|
||||||
|
String className, String fieldList) {
|
||||||
|
writer.println("\tstatic class " + className + " extends " + baseName + " {");
|
||||||
|
|
||||||
|
writer.println("\t\t" + className + "(" + fieldList + ") {");
|
||||||
|
|
||||||
|
String[] fields = fieldList.split(", ");
|
||||||
|
for (String field : fields) {
|
||||||
|
String name = field.split(" ")[1];
|
||||||
|
writer.println("\t\t\tthis." + name + " = " + name + ";");
|
||||||
|
}
|
||||||
|
|
||||||
|
writer.println("\t\t}");
|
||||||
|
|
||||||
|
writer.println();
|
||||||
|
writer.println("\t\t@Override");
|
||||||
|
writer.println("\t\t<R> R accept(Visitor<R> visitor) {");
|
||||||
|
writer.println("\t\t\treturn visitor.visit" +
|
||||||
|
className + baseName + "(this);");
|
||||||
|
writer.println("\t\t}");
|
||||||
|
|
||||||
|
|
||||||
|
writer.println();
|
||||||
|
for (String field : fields) {
|
||||||
|
writer.println("\t\tfinal " + field + ";");
|
||||||
|
}
|
||||||
|
|
||||||
|
writer.println("\t}");
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
Loading…
Reference in New Issue
Block a user