A2

附录 II

为了您的了解，这里是我们生成的代码，由 我们构建的小脚本 自动生成 jlox 语法树类。

A2 . 1表达式

表达式是我们看到的第一个语法树节点，在“代码表示”中介绍。主要的 Expr 类定义了用于根据特定表达式类型进行分派的访问者接口，并将其他表达式子类作为嵌套类包含在内。

lox/Expr.java
创建新文件
package com.craftinginterpreters.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);
  }

  // Nested Expr classes here...

  abstract <R> R accept(Visitor<R> visitor);
}
lox/Expr.java，创建新文件

A2 . 1 . 1赋值表达式

变量赋值在“语句和状态”中介绍。

lox/Expr.java
嵌套在 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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 2二元表达式

二元运算符在“代码表示”中介绍。

lox/Expr.java
嵌套在 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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 3调用表达式

函数调用表达式在“函数”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 4获取表达式

属性访问或“获取”表达式在“类”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 5分组表达式

使用圆括号对表达式进行分组是在“代码表示”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 6字面量表达式

字面量值表达式在“代码表示”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 7逻辑表达式

逻辑 and 和 or 运算符在“控制流”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 8设置表达式

属性赋值或“设置”表达式在“类”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 9超级表达式

super 表达式在“继承”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 10此表达式

this 表达式在“类”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 11一元表达式

一元运算符在“代码表示”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 1 . 12变量表达式

变量访问表达式在“语句和状态”中介绍。

lox/Expr.java
嵌套在 Expr 类中
  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;
  }
lox/Expr.java，嵌套在 Expr 类中

A2 . 2语句

语句形成一个独立于表达式的第二个语法树节点层次结构。我们在“语句和状态”中添加了前几个。

lox/Stmt.java
创建新文件
package com.craftinginterpreters.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);
  }

  // Nested Stmt classes here...

  abstract <R> R accept(Visitor<R> visitor);
}
lox/Stmt.java，创建新文件

A2 . 2 . 1块语句

定义局部作用域的带花括号的块语句在“语句和状态”中介绍。

lox/Stmt.java
嵌套在 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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 2类语句

类声明在，不出所料，“类”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 3表达式语句

表达式语句在“语句和状态”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 4函数语句

函数声明在，你猜对了，“函数”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 5如果语句

if 语句在“控制流”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 6打印语句

print 语句在“语句和状态”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 7返回语句

你需要一个函数来从中返回，因此 return 语句在“函数”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 8变量语句

变量声明在“语句和状态”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中

A2 . 2 . 9while 语句

while 语句在“控制流”中介绍。

lox/Stmt.java
嵌套在 Stmt 类中
  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;
  }
lox/Stmt.java，嵌套在 Stmt 类中