使用Visitor模式计算结果

为了给前面的算术表达式语法分析器计算出结果，我们还需要做些其它的事情。

ANTLR v4鼓励我们保持语法的整洁，使用语法分析树Visitor和其它遍历器来实现语言应用。不过在接触这些之前，我们需要对语法做些修改。

首先，我们需要用标签标明规则的选项，标签可以是和规则名没有冲突的任意标志符。如果选项上没有标签，ANTLR只会为每个规则生成一个visit方法。

在本例中，我们希望为每个选项生成一个不同的visit方法，以便每种输入短语都能得到不同的事件。在新的语法中，标签出现在选项的右边缘，且以“#”符号开头：

  1. stat
  2.     : expr                   # printExpr
  3.     | ID '=' expr            # assign
  4.     ;
  6. expr
  7.     : expr op=(MUL|DIV) expr # MulDiv
  8.     | expr op=(ADD|SUB) expr # AddSub
  9.     | INT                    # int
  10.     | ID                     # id
  11.     | '(' expr ')'           # parens
  12.     ;

接下来，让我们为运算符字面量定义一些记号名字，以便以后可以在visit方法中引用作为Java常量的它们：

  1. MUL : '*' ;
  3. DIV : '/' ;
  5. ADD : '+' ;
  7. SUB : '-' ;

现在，我们有了一个增强型的语法。接下来要做的事情是实现一个EvalVisitor类，它通过遍历表达式语法分析树计算和返回值。

执行下面的命令，让ANTLR生成Visitor接口和它的默认实现，其中-no-listener参数是告诉ANTLR不再生成Listener相关的代码：

  1. antlr -no-listener -visitor Calc.g

所有被标签标明的选项在生成的Visitor接口中都定义了一个visit方法：

  1. public interface CalcVisitor<T> extends ParseTreeVisitor<T> {
  2.     T visitProg(CalcParser.ProgContext ctx);
  3.     T visitPrintExpr(CalcParser.PrintExprContext ctx);
  4.     T visitAssign(CalcParser.AssignContext ctx);
  5.     ...
  6. }

接口定义使用的是Java泛型，visit方法的返回值为参数化类型，这允许我们根据表达式计算返回值的类型去设定实现的泛型参数。因为表达式的计算结果是整型，所以我们的EvalVisitor应该继承CalcBaseVisitor<Integer>类。为计算语法分析树的每个节点，我们需要覆写与语句和表达式选项相关的方法。这里是全部的代码：

  1. public class EvalVisitor extends CalcBaseVisitor<Integer> {
  2.     /** "memory" for our calculator; variable/value pairs go here */
  3.     Map<String, Integer> memory = new HashMap<String, Integer>();
  5.     /** ID '=' expr */
  6.     @Override
  7.     public Integer visitAssign(CalcParser.AssignContext ctx) {
  8.         String id = ctx.ID().getText();  // id is left-hand side of '='
  9.         int value = visit(ctx.expr());   // compute value of expression on right
  10.         memory.put(id, value);           // store it in our memory
  11.         return value;
  12.     }
  14.     /** expr */
  15.     @Override
  16.     public Integer visitPrintExpr(CalcParser.PrintExprContext ctx) {
  17.         Integer value = visit(ctx.expr()); // evaluate the expr child
  18.         System.out.println(value);         // print the result
  19.         return 0;                          // return dummy value
  20.     }
  22.     /** INT */
  23.     @Override
  24.     public Integer visitInt(CalcParser.IntContext ctx) {
  25.         return Integer.valueOf(ctx.INT().getText());
  26.     }
  28.     /** ID */
  29.     @Override
  30.     public Integer visitId(CalcParser.IdContext ctx) {
  31.         String id = ctx.ID().getText();
  32.         if ( memory.containsKey(id) ) return memory.get(id);
  33.         return 0;
  34.     }
  36.     /** expr op=('*'|'/') expr */
  37.     @Override
  38.     public Integer visitMulDiv(CalcParser.MulDivContext ctx) {
  39.         int left = visit(ctx.expr(0));  // get value of left subexpression
  40.         int right = visit(ctx.expr(1)); // get value of right subexpression
  41.         if ( ctx.op.getType() == CalcParser.MUL ) return left * right;
  42.         return left / right; // must be DIV
  43.     }
  45.     /** expr op=('+'|'-') expr */
  46.     @Override
  47.     public Integer visitAddSub(CalcParser.AddSubContext ctx) {
  48.         int left = visit(ctx.expr(0));  // get value of left subexpression
  49.         int right = visit(ctx.expr(1)); // get value of right subexpression
  50.         if ( ctx.op.getType() == CalcParser.ADD ) return left + right;
  51.         return left - right; // must be SUB
  52.     }
  54.     /** '(' expr ')' */
  55.     @Override
  56.     public Integer visitParens(CalcParser.ParensContext ctx) {
  57.         return visit(ctx.expr()); // return child expr's value
  58.     }
  59. }

以前开发和测试语法都是使用的TestRig，这次我们试着编写计算器的主程序来启动代码：

  1. public class Calc {
  3.     public static void main(String[] args) throws Exception {
  4.         InputStream is = args.length > 0 ? new FileInputStream(args[0]) : System.in;
  6.         ANTLRInputStream input = new ANTLRInputStream(is);
  7.         CalcLexer lexer = new CalcLexer(input);
  8.         CommonTokenStream tokens = new CommonTokenStream(lexer);
  9.         CalcParser parser = new CalcParser(tokens);
  10.         ParseTree tree = parser.prog();
  12.         EvalVisitor eval = new EvalVisitor();
  13.         // 开始遍历语法分析树
  14.         eval.visit(tree);
  16.         System.out.println(tree.toStringTree(parser));
  17.     }
  18. }

创建一个运行主程序的脚本：

  1. #!/bin/sh
  2. java -cp .:./antlr-4.5.1-complete.jar:$CLASSPATH $*

把它保存为run.sh后，执行以下命令：

  1. compile *.java
  2. run Calc calc.txt

然后你就会看到文本形式的语法分析树以及计算结果：

  1. 193
  2. 17
  3. 9
  4. (prog (stat (expr 193)) (stat a = (expr 5)) (stat b = (expr 6))
  5.  (stat (expr (expr a) + (expr (expr b) * (expr 2)))) (stat (expr
  6.  (expr ( (expr (expr 1) + (expr 2)) )) * (expr 3))))