From e9c0fe6f5f8c5e6b0ecc97d6b7f3a1dd6970dd1d Mon Sep 17 00:00:00 2001 From: Michael Thomson Date: Thu, 10 Apr 2025 09:37:19 -0400 Subject: [PATCH] Chapter 5: Representing Code --- .../craftinginterpreters/lox/AstPrinter.java | 55 +++++++++++ .../com/craftinginterpreters/lox/Expr.java | 68 +++++++++++++ .../tool/GenerateAst.java | 95 +++++++++++++++++++ 3 files changed, 218 insertions(+) create mode 100644 jlox/src/main/java/com/craftinginterpreters/lox/AstPrinter.java create mode 100644 jlox/src/main/java/com/craftinginterpreters/lox/Expr.java create mode 100644 jlox/src/main/java/com/craftinginterpreters/tool/GenerateAst.java diff --git a/jlox/src/main/java/com/craftinginterpreters/lox/AstPrinter.java b/jlox/src/main/java/com/craftinginterpreters/lox/AstPrinter.java new file mode 100644 index 0000000..e80091b --- /dev/null +++ b/jlox/src/main/java/com/craftinginterpreters/lox/AstPrinter.java @@ -0,0 +1,55 @@ +package com.craftinginterpreters.lox; + +class AstPrinter implements Expr.Visitor { + String print(Expr expr) { + return expr.accept(this); + } + + @Override + public String visitBinaryExpr(Expr.Binary expr) { + return parenthesize(expr.operator.lexeme, expr.left, expr.right); + } + + @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 visitUnaryExpr(Expr.Unary expr) { + return parenthesize(expr.operator.lexeme, expr.right); + } + + 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(); + } + + public static void main(String[] args) { + Expr expression = new Expr.Binary( + new Expr.Unary( + new Token(TokenType.MINUS, "-", null, 1), + new Expr.Literal(123)), + new Token(TokenType.STAR, "*", null, 1), + new Expr.Grouping( + new Expr.Literal(45.67))); + + System.out.println(new AstPrinter().print(expression)); + } + +} diff --git a/jlox/src/main/java/com/craftinginterpreters/lox/Expr.java b/jlox/src/main/java/com/craftinginterpreters/lox/Expr.java new file mode 100644 index 0000000..54183de --- /dev/null +++ b/jlox/src/main/java/com/craftinginterpreters/lox/Expr.java @@ -0,0 +1,68 @@ +package com.craftinginterpreters.lox; + +import java.util.List; + +abstract class Expr { + interface Visitor { + R visitBinaryExpr(Binary expr); + R visitGroupingExpr(Grouping expr); + R visitLiteralExpr(Literal expr); + R visitUnaryExpr(Unary expr); + } + static class Binary extends Expr { + Binary(Expr left, Token operator, Expr right) { + this.left = left; + this.operator = operator; + this.right = right; + } + + @Override + R accept(Visitor visitor) { + return visitor.visitBinaryExpr(this); + } + + final Expr left; + final Token operator; + final Expr right; + } + static class Grouping extends Expr { + Grouping(Expr expression) { + this.expression = expression; + } + + @Override + R accept(Visitor visitor) { + return visitor.visitGroupingExpr(this); + } + + final Expr expression; + } + static class Literal extends Expr { + Literal(Object value) { + this.value = value; + } + + @Override + R accept(Visitor visitor) { + return visitor.visitLiteralExpr(this); + } + + final Object value; + } + static class Unary extends Expr { + Unary(Token operator, Expr right) { + this.operator = operator; + this.right = right; + } + + @Override + R accept(Visitor visitor) { + return visitor.visitUnaryExpr(this); + } + + final Token operator; + final Expr right; + } + + abstract R accept(Visitor visitor); +} diff --git a/jlox/src/main/java/com/craftinginterpreters/tool/GenerateAst.java b/jlox/src/main/java/com/craftinginterpreters/tool/GenerateAst.java new file mode 100644 index 0000000..549de0a --- /dev/null +++ b/jlox/src/main/java/com/craftinginterpreters/tool/GenerateAst.java @@ -0,0 +1,95 @@ +package com.craftinginterpreters.tool; + +import java.io.IOException; +import java.io.PrintWriter; +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 "); + System.exit(64); + } + String outputDir = args[0]; + defineAst(outputDir, "Expr", Arrays.asList( + "Binary : Expr left, Token operator, Expr right", + "Grouping : Expr expression", + "Literal : Object value", + "Unary : Token operator, Expr right")); + } + + private static void defineAst(String outputDir, String baseName, List types) throws IOException { + String path = outputDir + "/" + baseName + ".java"; + PrintWriter writer = new PrintWriter(path, "UTF-8"); + + writer.println("package com.craftinginterpreters.lox;"); + writer.println(); + writer.println("import java.util.List;"); + writer.println(); + writer.println("abstract class " + baseName + " {"); + + defineVisitor(writer, baseName, types); + + // The AST classes. + 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(" abstract R accept(Visitor visitor);"); + + writer.println("}"); + writer.close(); + } + + private static void defineVisitor(PrintWriter writer, String baseName, List types) { + writer.println(" interface Visitor {"); + + for (String type : types) { + String typeName = type.split(":")[0].trim(); + writer.println(" R visit" + typeName + baseName + "(" + + typeName + " " + baseName.toLowerCase() + ");"); + } + + writer.println(" }"); + } + + private static void defineType( + PrintWriter writer, String baseName, + String className, String fieldList) { + writer.println(" static class " + className + " extends " + + baseName + " {"); + + // Constructor. + writer.println(" " + className + "(" + fieldList + ") {"); + + // Store parameters in fields. + String[] fields = fieldList.split(", "); + for (String field : fields) { + String name = field.split(" ")[1]; + writer.println(" this." + name + " = " + name + ";"); + } + + writer.println(" }"); + + // Visitor pattern. + writer.println(); + writer.println(" @Override"); + writer.println(" R accept(Visitor visitor) {"); + writer.println(" return visitor.visit" + + className + baseName + "(this);"); + writer.println(" }"); + + // Fields. + writer.println(); + for (String field : fields) { + writer.println(" final " + field + ";"); + } + + writer.println(" }"); + } + +}