快速上手ANTLR

回顾前文：

• ANTLR 简单介绍
• ANTLR 相关术语
• ANTLR 环境准备

下面通过两个实例来快速上手ANTLR。

使用Listener转换数组

完整源码见：https://github.com/bytesfly/antlr-demo/tree/main/array-init/src/main/java/com/github/bytesfly/arr

效果如下图所示：

该程序能识别输入的整数数组并将其转化为JSON格式的字符串数组。

语法规则为ArrayInit.g4，如下：

/** Grammars always start with a grammar header. This grammar is called
 *  ArrayInit and must match the filename: ArrayInit.g4
 */
grammar ArrayInit;

@header {package com.github.bytesfly.arr.antlr;}

/** A rule called init that matches comma-separated values between {...}. */
init  : '{' value (',' value)* '}' ;  // must match at least one value

/** A value can be either a nested array/struct or a simple integer (INT) */
value : init
      | INT
      ;

// parser rules start with lowercase letters, lexer rules with uppercase
INT :   [0-9]+ ;             // Define token INT as one or more digits
WS  :   [ \t\r\n]+ -> skip ; // Define whitespace rule, toss it out

我们自定义IntToStringListener.java，如下：

public class IntToStringListener extends ArrayInitBaseListener {

    private final StringBuilder builder = new StringBuilder();

    /**
     * Translate { to [
     */
    @Override
    public void enterInit(ArrayInitParser.InitContext ctx) {
        builder.append('[');
    }

    /**
     * Translate } to ]
     */
    @Override
    public void exitInit(ArrayInitParser.InitContext ctx) {
        // 去除value节点后的逗号
        builder.setLength(builder.length() - 1);
        builder.append(']');

        if (ctx.parent != null) {
            // 嵌套结构需要追加逗号，与enterValue的处理保持一致
            builder.append(',');
        }
    }

    /**
     * Translate integers to strings with ""
     */
    @Override
    public void enterValue(ArrayInitParser.ValueContext ctx) {
        TerminalNode node = ctx.INT();
        if (node != null) {
            builder.append("\"").append(node.getText()).append("\",");
        }
    }

    public String getResult() {
        return builder.toString();
    }
}

最终的转换程序为Translate.java，如下：

public class Translate {

    public static void main(String[] args) throws Exception {
        // 从键盘输入
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {

            String s = sc.nextLine();

            // 从字符串读取输入数据
            CharStream input = CharStreams.fromString(s);

            // 新建一个词法分析器
            ArrayInitLexer lexer = new ArrayInitLexer(input);

            // 新建一个词法符号的缓冲区，用于存储词法分析器将生成的词法符号
            CommonTokenStream tokens = new CommonTokenStream(lexer);

            // 新建一个语法分析器，处理词法符号缓冲区中的内容
            ArrayInitParser parser = new ArrayInitParser(tokens);

            // 针对init规则，开始语法分析
            ParseTree tree = parser.init();

            // 新建一个通用的、能够触发回调函数的语法分析树遍历器
            ParseTreeWalker walker = new ParseTreeWalker();

            // 创建我们自定义的监听器
            IntToStringListener listener = new IntToStringListener();

            // 遍历语法分析过程中生成的语法分析树，触发回调
            walker.walk(listener, tree);

            // 打印转换结果
            System.out.println(listener.getResult());
        }
    }
}

监听器机制的优雅之处在于，不需要自己编写任何遍历语法分析树的代码。事实上，我们甚至都不知道ANTLR运行库是怎么遍历语法分析树、怎么调用我们的方法的。我们只知道，在语法规则对应的语句的开始和结束位置处，我们的监听器方法可以得到通知。

当然如果想知道ANTLR运行库是怎么遍历语法分析树并不困难，见org.antlr.v4.runtime.tree.ParseTreeWalker#walk()：

public void walk(ParseTreeListener listener, ParseTree t) {
    if ( t instanceof ErrorNode) {
        listener.visitErrorNode((ErrorNode)t);
        return;
    }
    else if ( t instanceof TerminalNode) {
        listener.visitTerminal((TerminalNode)t);
        return;
    }
    RuleNode r = (RuleNode)t;
    enterRule(listener, r);
    int n = r.getChildCount();
    for (int i = 0; i<n; i++) {
        walk(listener, r.getChild(i));
    }
    exitRule(listener, r);
}

这段代码也非常容易懂，其实就是常规树的遍历，遍历过程中反调自定义的IntToStringListener中的实现方法。

使用Visitor构建计算器

完整源码见：https://github.com/bytesfly/antlr-demo/tree/main/calculator/src/main/java/com/github/bytesfly/calculator

该程序能识别赋值语句并做加减乘除四则运算，效果大致如下。

输入：

100
a = 1
b = 2
a+b*2
((2+3)*(6+1)-5) / 3

输出：

100
5
10

语法规则为Expr.g4，如下：

grammar Expr;

@header {package com.github.bytesfly.calculator.antlr;}

/** The start rule; begin parsing here. */
prog:   stat+ ;

stat:   expr NEWLINE                # printExpr
    |   ID '=' expr NEWLINE         # assign
    |   NEWLINE                     # blank
    ;

expr:   expr op=('*'|'/') expr      # MulDiv
    |   expr op=('+'|'-') expr      # AddSub
    |   INT                         # int
    |   ID                          # id
    |   '(' expr ')'                # parens
    ;

MUL :   '*' ; // assigns token name to '*' used above in grammar
DIV :   '/' ;
ADD :   '+' ;
SUB :   '-' ;
ID  :   [a-zA-Z]+ ;      // match identifiers
INT :   [0-9]+ ;         // match integers
NEWLINE:'\r'? '\n' ;     // return newlines to parser (is end-statement signal)
WS  :   [ \t]+ -> skip ; // toss out whitespace

编写一个用于处理计算逻辑的访问器EvalVisitor.java，如下：

public class EvalVisitor extends ExprBaseVisitor<Integer> {

    /**
     * 存放变量名和变量值的对应关系
     */
    private final Map<String, Integer> memory = new HashMap<>();

    /**
     * ID '=' expr NEWLINE  # assign
     */
    @Override
    public Integer visitAssign(ExprParser.AssignContext ctx) {
        // 获取变量名
        String id = ctx.ID().getText();
        // 计算表达式的值
        Integer value = visit(ctx.expr());
        // 暂存到map中
        memory.put(id, value);

        return value;
    }

    /**
     * expr NEWLINE  # printExpr
     */
    @Override
    public Integer visitPrintExpr(ExprParser.PrintExprContext ctx) {
        // 计算表达式的值
        Integer value = visit(ctx.expr());
        // 打印
        System.out.println(value);

        return 0;
    }

    /**
     * INT  # int
     */
    @Override
    public Integer visitInt(ExprParser.IntContext ctx) {
        return Integer.valueOf(ctx.INT().getText());
    }

    /**
     * ID  # id
     */
    @Override
    public Integer visitId(ExprParser.IdContext ctx) {
        String id = ctx.ID().getText();
        return memory.getOrDefault(id, 0);
    }

    /**
     * expr op=('*'|'/') expr  # MulDiv
     */
    @Override
    public Integer visitMulDiv(ExprParser.MulDivContext ctx) {
        // 计算左侧子表达式的值
        Integer left = visit(ctx.expr(0));
        // 计算右侧子表达式的值
        Integer right = visit(ctx.expr(1));

        // 根据不同的操作符做相应的运算
        if (ctx.op.getType() == ExprParser.MUL) {
            return left * right;
        } else {
            return left / right;
        }
    }

    /**
     * expr op=('+'|'-') expr  # AddSub
     */
    @Override
    public Integer visitAddSub(ExprParser.AddSubContext ctx) {
        // 计算左侧子表达式的值
        Integer left = visit(ctx.expr(0));
        // 计算右侧子表达式的值
        Integer right = visit(ctx.expr(1));

        // 根据不同的操作符做相应的运算
        if (ctx.op.getType() == ExprParser.ADD) {
            return left + right;
        } else {
            return left - right;
        }
    }

    /**
     * '(' expr ')'  # parens
     */
    @Override
    public Integer visitParens(ExprParser.ParensContext ctx) {
        // 返回子表达式的值
        return visit(ctx.expr());
    }
}

最终能识别输入表达式并做加减乘除四则运算的Calc.java，如下：

public class Calc {
    public static void main(String[] args) throws Exception {
        // 读取resources目录下example.expr表达式文件
        String s = FileUtil.readUtf8String("example.expr");

        // 从字符串读取输入数据
        CharStream input = CharStreams.fromString(s);

        // 新建一个词法分析器
        ExprLexer lexer = new ExprLexer(input);

        // 新建一个词法符号的缓冲区，用于存储词法分析器将生成的词法符号
        CommonTokenStream tokens = new CommonTokenStream(lexer);

        // 新建一个语法分析器，处理词法符号缓冲区中的内容
        ExprParser parser = new ExprParser(tokens);

        // 针对prog规则，开始语法分析
        ParseTree tree = parser.prog();

        // 创建访问器对象
        EvalVisitor eval = new EvalVisitor();
        // 访问语法树
        eval.visit(tree);
    }
}

对整个调用过程疑惑的朋友，建议自行下载源码，打断点观察执行逻辑。

从上面的例子可以看出：使用ANTLR4语法文件独立于程序，具有编程语言中立性。

访问器机制也使得语言识别之外的工作在我们所熟悉的Java领域进行。在生成的所需的语法分析器之后，就不再需要同ANTLR语法标记打交道了。