Representing code chapter

src/lox/AstPrinter.java

@@ -0,0 +1,42 @@
+package lox;
+
+public class AstPrinter implements Expr.Visitor<String> {
+    String print(Expr expr) {
+        return expr.accept(this);
+    }
+
+    @Override
+    public String visitBinaryExpr(Expr.Binary expr) {
+        return parethesize(expr.operator.lexeme,
+                expr.left, expr.right);
+    }
+
+    @Override
+    public String visitGroupingExpr(Expr.Grouping expr) {
+        return parethesize("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 parethesize(expr.operator.lexeme, expr.right);
+    }
+
+    private String parethesize(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();
+    }
+}

src/lox/Expr.java

@@ -0,0 +1,68 @@
+package lox;
+
+import java.util.List;
+
+abstract class Expr {
+	interface Visitor<R> {
+		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> R accept(Visitor<R> 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> 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 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;
+	}
+
+	abstract <R> R accept(Visitor<R> visitor);
+}

src/tool/GenerateAst.java

@@ -0,0 +1,96 @@
+package tool;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+import java.util.List;
+
+public class GenerateAst {
+    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
+        if (args.length != 1) {
+            System.err.println("Usage: generate_ast <output directory>");
+            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<String> types) throws FileNotFoundException, UnsupportedEncodingException {
+        String path = outputDir + "/" + baseName + ".java";
+        PrintWriter writer = new PrintWriter(path, "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}");
+    }
+
+}