计算器
语法文件
实现一个简单的计算器，可以对如下表达式进行识别
193
a = 5
b = 6
a+b*2
(1+2)*3
如下为匹配规则的语法文件Expr.g4
grammar Expr;
/** 起始规则，语法分析的起点 */
prog: stat+ ;
stat: expr NEWLINE //匹配expr表达式 + 换行
| ID '=' expr NEWLINE //匹配 变量 = 表达式 换行
| NEWLINE //匹配换行
;
expr: expr ('*'|'/') expr //匹配表达式*/
| expr ('+'|'-') expr //匹配表达式+-
| INT //整数
| ID //变量
| '(' expr ')' //括号
;
//词法分析器
ID : [a-zA-Z]+ ; // 由字母组成的变量名
INT : [0-9]+ ; // 数字
NEWLINE:'\r'? '\n' ; // 换行
WS : [ \t]+ -> skip ; // 匹配空白，按->skip命令跳过
左递归规则：例如在语法规则expr: expr ('*'|'/') expr中，expr在备选分支的起始位置对自身进行了递归调用
使用antlr运行编译，然后利用TestBig工具进行测试
D:\Code\antlr\demo\chapter4>antlr4 Expr.g4 # 生成语法、词法分析器
D:\Code\antlr\demo\chapter4>javac *.java # 编译相关文件
# 对语法Expr进行测试，初始规则prog，输入文件t.expr，并以可视化的方式输出结果
D:\Code\antlr\demo\chapter4>grun Expr prog -gui t.expr
生成的语法分析树如下所示
文件引入
在一个庞大的项目中，通常将语法文件拆分为语法规则文件和词法规则文件，这样有一些重复的词法规则就可以放在一个文件中以实现重用，当需要使用的时候再将文件引入。
如下所示，将所有词法规则放到文件CommonLexerRules.g4中
lexer grammar CommonLexerRules; // 词法文件以关键字"lexer grammar"开头
ID : [a-zA-Z]+ ;
INT : [0-9]+ ;
NEWLINE:'\r'? '\n' ;
WS : [ \t]+ -> skip ;
然后在语法规则文件LibExpr.g4中引入所需的文件，之后我们只需要对LibExpr运行antlr构建工具即可，不需要再手动操作导入的文件
grammar LibExpr;
import CommonLexerRules; // 引入词法文件
prog: stat+ ;
stat: expr NEWLINE
| ID '=' expr NEWLINE
| NEWLINE
;
expr: expr ('*'|'/') expr
| expr ('+'|'-') expr
| INT
| ID
| '(' expr ')'
;
错误处理
ANTLR语法分析器能够自动识别语法报告中的错误并从错误中恢复。
如下所示，在输入中少了一个括号，语法分析树会输出提示信息，并且会继续向后匹配
D:\Code\antlr\demo\chapter4>grun LibExpr prog -tree
(1+2
3+4
^Z
line 1:4 mismatched input '\r\n' expecting {'*', '/', '+', '-', ')'} # 提示缺失
(prog (stat (expr ( (expr (expr 1) + (expr 2)) <missing ')'>) \r\n) (stat (expr (expr 3) + (expr 4)) \r\n))\ # 不影响继续匹配
如果使用gui的方式，会在确实的节点显示为红色
使用访问器遍历树
在构建了语法分析树后，使用访问器对节点进行遍历从而得出计算结果。访问器机制和监听器机制最大的区别在于，监听器方法会被遍历器自动调用，而访问器必须手动调用visit()方法实现对子节点的访问。
在使用访问器之前，需要对语法文件的每个分支添加标签，ANTLR会为每个标签生成相应的方法，否则只会默认为每个规则生成一个方法。如下所示为语法规则文件LabeledExpr.g4，标签以#开头，放在分支右侧
grammar LabeledExpr;
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
;
//在语法文件中，为词法符号命名，这样在Java中就可以当作常量来访问了
MUL : '*' ; // 将 '*' 命名为MUL
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 ;
对上述语法文件运行ANTLR构建工具，通过命令参数-visitor指定生成包含访问器的代码
antlr4 -no-listener -visitor LabeledExpr.g4
自动生成访问器接口类LabeledExprVisitor，之前在语法文件中定义的标签都会生成对应的方法，传入相应的上下文作为参数，并且以泛型的方式定义接口类，我们可以根据需要自定义返回值类型。同时生成了接口的默认实现类LabeledExprBaseVisitor
public interface LabeledExprVisitor<T> extends ParseTreeVisitor<T> {
T visitProg(LabeledExprParser.ProgContext ctx); //访问Prog标签
T visitPrintExpr(LabeledExprParser.PrintExprContext ctx); //访问PrintExpr标签
T visitAssign(LabeledExprParser.AssignContext ctx); //访问Assign标签
......
}
public class LabeledExprBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements LabeledExprVisitor<T> {
@Override public T visitProg(LabeledExprParser.ProgContext ctx) { return visitChildren(ctx); }
@Override public T visitPrintExpr(LabeledExprParser.PrintExprContext ctx) { return visitChildren(ctx); }
@Override public T visitAssign(LabeledExprParser.AssignContext ctx) { return visitChildren(ctx); }
......
}
通过继承LabeledExprBaseVisitor，实现自定义访问器类EvalVisitor ，在其中实现具体访问节点的代码，完成计算器的运算操作。注意在每个visitXxx()方法中都通过visit()方法手动对子节点进行访问
import java.util.HashMap;
import java.util.Map;
public class EvalVisitor extends LabeledExprBaseVisitor<Integer> {
/** 计算器的“内存”，存放<变量名, 变量值> */
Map<String, Integer> memory = new HashMap<String, Integer>();
/** ID '=' expr NEWLINE */
@Override
public Integer visitAssign(LabeledExprParser.AssignContext ctx) {
String id = ctx.ID().getText(); // 获取=左边的变量
int value = visit(ctx.expr()); // 计算右侧表达式的值
memory.put(id, value); // 将计算结果储存到“内存”中
return value;
}
/** expr NEWLINE */
@Override
public Integer visitPrintExpr(LabeledExprParser.PrintExprContext ctx) {
Integer value = visit(ctx.expr()); // 计算子节点的值
System.out.println(value); // 打印结果
return 0; // 返回虚值
}
/** INT */
@Override
public Integer visitInt(LabeledExprParser.IntContext ctx) {
return Integer.valueOf(ctx.INT().getText());
}
/** ID */
@Override
public Integer visitId(LabeledExprParser.IdContext ctx) {
String id = ctx.ID().getText();
if ( memory.containsKey(id) ) return memory.get(id);
return 0;
}
/** expr op=('*'|'/') expr */
@Override
public Integer visitMulDiv(LabeledExprParser.MulDivContext ctx) {
int left = visit(ctx.expr(0)); // 递归计算左侧表达式的值
int right = visit(ctx.expr(1)); // 计算右侧表达式的值
if ( ctx.op.getType() == LabeledExprParser.MUL ) return left * right; //两值相乘
return left / right; // 或者相除
}
/** expr op=('+'|'-') expr */
@Override
public Integer visitAddSub(LabeledExprParser.AddSubContext ctx) {
int left = visit(ctx.expr(0)); // get value of left subexpression
int right = visit(ctx.expr(1)); // get value of right subexpression
if ( ctx.op.getType() == LabeledExprParser.ADD ) return left + right;
return left - right; // must be SUB
}
/** '(' expr ')' */
@Override
public Integer visitParens(LabeledExprParser.ParensContext ctx) {
return visit(ctx.expr()); // 返回子表达式的值
}
}
最后实现一个主程序Calc.java对语法分析树进行遍历，计算结果
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.ParseTree;
import java.io.FileInputStream;
import java.io.InputStream;
public class Calc {
public static void main(String[] args) throws Exception {
String inputFile = null;
if ( args.length>0 ) inputFile = args[0];
InputStream is = System.in; //从标准输入获取字符
if ( inputFile!=null ) is = new FileInputStream(inputFile); //从文件获取输入字符
ANTLRInputStream input = new ANTLRInputStream(is);
LabeledExprLexer lexer = new LabeledExprLexer(input); //词法分析器
CommonTokenStream tokens = new CommonTokenStream(lexer); //将词法分析器产生的词法符号放到缓冲区
ArrayInitParser parser = new ArrayInitParser(tokens); //将词法符号送入语法分析器
ParseTree tree = parser.prog(); //开始分析
EvalVisitor eval = new EvalVisitor(); //创建访问器
eval.visit(tree); //开始遍历分析树
}
}
对上述文件进行编译、运行Calc，可以看到输出计算结果
D:\Code\antlr\demo\chapter4>javac *.java
D:\Code\antlr\demo\chapter4>java Calc
(1+2)
3+4
^Z
3
7