Idea中使用Antlr4
一、新建一个MAVEN项目
(1)new -> project ->maven
(2)在pom文件中引入antlr相关的依赖
pom.xml文件如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.wyf</groupId>
<artifactId>Antlr</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.antlr</groupId>
<artifactId>antlr4-runtime</artifactId>
<version>4.9.1</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.antlr</groupId>
<artifactId>antlr4</artifactId>
<version>4.9</version>
<executions>
<execution>
<id>antlr</id>
<goals>
<goal>antlr4</goal>
</goals>
<phase>none</phase>
</execution>
</executions>
<configuration>
<outputDirectory>src/test/java</outputDirectory>
<listener>true</listener>
<treatWarningsAsErrors>true</treatWarningsAsErrors>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
(3)安装Antlr插件
二、antlr在idea中的使用
(1)新建一个.g4文件,我在这里新建了一个Calculator.g4文件,来定义一个计算器的文法
grammar Calculator;
prog : stat+;
stat:
expr NEWLINE # print
| ID '=' expr NEWLINE # assign
| NEWLINE # blank
;
expr:
expr op=('*'|'/') expr # MulDiv
| expr op=('+'|'-') expr # AddSub
| INT # int
| ID # id
| '(' expr ')' # parenthese
;
MUL : '*' ;
DIV : '/' ;
ADD : '+' ;
SUB : '-' ;
ID : [a-zA-Z]+ ;
INT : [0-9]+ ;
NEWLINE :'\r'? '\n' ;
DELIMITER : ';';
WS : [ \t]+ -> skip;
(2)设置ANTLR的config
如果Output directory where all output is generated 不填写,会在项目的根目录下生成一个gen的文件夹
(3)生成相关文件
(4)生成之后的文件
(5)为了看着舒服,我还是把文件移动了
(6)检验文法(一定要在.g4文件的开始那行右击)
三、抽象语法树的访问(Vistor方式)
抽象语法树的例子
(1)新建一个类继承CalculatorBaseVisitor,实现对抽象语法树节点的遍历,实现计算的功能
(2)CalculatorBaseVisitorImp文件的内容
package com.wyf.ast.astImp;
import com.wyf.ast.parser.CalculatorBaseVisitor;
import com.wyf.ast.parser.CalculatorParser;
import java.util.HashMap;
/**
* @author: wyf
* @date:2022/4/20 21:58
*/
public class CalculatorVistorImp extends CalculatorBaseVisitor<Integer> {
//存储变量的值
private HashMap<String, Integer> variable = new HashMap<>();
public CalculatorVistorImp() {
this.variable = variable;
}
//遇到print节点,计算结果,打印出来
@Override
public Integer visitPrint(CalculatorParser.PrintContext ctx) {
Integer result = ctx.expr().accept(this);
System.out.println(result);
return null;
}
//分别获取expr节点的值,并计算乘除结果
@Override
public Integer visitMulDiv(CalculatorParser.MulDivContext ctx) {
Integer param1 = ctx.expr(0).accept(this);
Integer param2 = ctx.expr(1).accept(this);
if(ctx.op.getType() == CalculatorParser.MUL){
return param1 * param2;
}
if(ctx.op.getType() == CalculatorParser.DIV){
return param1 / param2;
}
return null;
}
//分别获取expr节点的值,并计算结果
@Override
public Integer visitAddSub(CalculatorParser.AddSubContext ctx) {
Integer param1 = ctx.expr(0).accept(this);
Integer param2 = ctx.expr(1).accept(this);
if(ctx.op.getType() == CalculatorParser.ADD){
return param1 + param2;
}
if(ctx.op.getType() == CalculatorParser.SUB){
return param1 - param2;
}
return null;
}
//当遇到Id时从变量表获取数据
@Override
public Integer visitId(CalculatorParser.IdContext ctx) {
return variable.get(ctx.getText());
}
//当遇到Int节点时直接返回数据
@Override
public Integer visitInt(CalculatorParser.IntContext ctx) {
return Integer.parseInt(ctx.getText());
}
//当遇到赋值语句时,获取右边expr的值存储到变量表中
@Override
public Integer visitAssign(CalculatorParser.AssignContext ctx) {
String name = ctx.ID().getText();
Integer value = ctx.expr().accept(this);
variable.put(name, value);
return super.visitAssign(ctx);
}
}
(3)测试类
test.java
package com.wyf.ast.test;
import com.wyf.ast.astImp.CalculatorVistorImp;
import com.wyf.ast.lexer.CalculatorLexer;
import com.wyf.ast.parser.CalculatorBaseVisitor;
import com.wyf.ast.parser.CalculatorParser;
import com.wyf.ast.parser.CalculatorVisitor;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
/**
* @author: wyf
* @date:2022/4/20 22:19
*/
public class test {
public static void main(String[] args) {
String expression = "a = 12\n" +
"b = a * 3\n" +
"a + b\n" +
"a - b\n";
CalculatorLexer lexer = new CalculatorLexer(CharStreams.fromString(expression));
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.setBuildParseTree(true);
ParseTree root = parser.prog();
CalculatorBaseVisitor<Integer> visitor = new CalculatorVistorImp();
root.accept(visitor);
}
}
例子分析(建议看完 三 和四 再回头看例子的分析)
生成的节点类
(1)计算器语法中定义了三条语法规则:prog, stat, expr。antlr4会为每条规则生成一个ParserRuleContext的子类。如果这个语法规则添加了标签,那么为每个标签也生成一个ParserRuleContext的子类,这些类之间的关系,如下图所示
各个类之间的继承关系如下图所示:
(2)这些类是如何联系起来的呢?
以 prog 规则为例,它对应 ProgContext 类。因为 prog 规则 可以包含多个 stat 规则,所以它必须提供访问子节点 StatContext 的方法。
public class CalculatorParser extends Parser {
public static class ProgContext extends ParserRuleContext {
//返回子节点stat列表
public List<StatContext> stat() {
return getRuleContexts(StatContext.class);
}
//返回第几个stat规则
public StatContext stat(int i) {
return getRuleContext(StatContext.class,i);
}
public ProgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
//返回该规则的id号, RULE_prog是一个常量
@Override public int getRuleIndex() { return RULE_prog; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).enterProg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).exitProg(this);
}
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof CalculatorVisitor ) return ((CalculatorVisitor<? extends T>)visitor).visitProg(this);
else return visitor.visitChildren(this);
}
}
}
继续看stat规则,它对应着StateContext类。因为它为每种情况添加了标签,所以也为每个标签生成了对应的类,这些类都是StateContext的子类
public class CalculatorParser extends Parser {
public static class StatContext extends ParserRuleContext {
public StatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
//返回规则的id
@Override
public int getRuleIndex() { return RULE_stat; }
public StatContext() { }
public void copyFrom(StatContext ctx) {
super.copyFrom(ctx);
}
}
public static class PrintContext extends StatContext {
//返回expr节点
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
//返回NEWLINE叶子节点
public TerminalNode NEWLINE() { return getToken(CalculatorParser.NEWLINE, 0); }
public PrintContext(StatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).enterPrint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).exitPrint(this);
}
//accept方法调用了visitor的visitPrint方法
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof CalculatorVisitor ) return ((CalculatorVisitor<? extends T>)visitor).visitPrint(this);
else return visitor.visitChildren(this);
}
//BlankContext AssignContext 原理类似
}
public static class BlankContext extends StatContext {
public TerminalNode NEWLINE() { return getToken(CalculatorParser.NEWLINE, 0); }
public BlankContext(StatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).enterBlank(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CalculatorListener ) ((CalculatorListener)listener).exitBlank(this);
}
//accpet方法调用了visitor的visitBlank方法。
@Override
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
if ( visitor instanceof CalculatorVisitor ) return ((CalculatorVisitor<? extends T>)visitor).visitBlank(this);
else return visitor.visitChildren(this);
}
}
}
这里只分析了prog 和stat规则, 其余的规则的原理是一样的
节点的访问方法
上面生成的节点类,都是ParserRuleContest的子类,都实现accept方法。每个类实现方法都不一样,比如ProgContex类,它的accept方法调用了访问者的visitProg方法。而PrintContext类的accept方法对应于访问者的visitPrint方法。
详细情况见上面的代码
CaculatorBaseVisitor提供了访问不同节点的方法,默认实现都是调用visit Children方法。它的泛型T表示返回的结果类型。使用者一般继承CaculatorBaseVisitor类,复写一些方法,来实现自定义的功能(比如上面的四则运算的例子)
public class CalculatorBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements CalculatorVisitor<T> {
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitProg(CalculatorParser.ProgContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitPrint(CalculatorParser.PrintContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitAssign(CalculatorParser.AssignContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitBlank(CalculatorParser.BlankContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitMulDiv(CalculatorParser.MulDivContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitAddSub(CalculatorParser.AddSubContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitParenthese(CalculatorParser.ParentheseContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitId(CalculatorParser.IdContext ctx) { return visitChildren(ctx); }
/**
* {@inheritDoc}
*
* <p>The default implementation returns the result of calling
* {@link #visitChildren} on {@code ctx}.</p>
*/
@Override public T visitInt(CalculatorParser.IntContext ctx) { return visitChildren(ctx); }
}
四、Antlr4基础类的介绍
(1)antlr4会将语句解析成一棵树,但是这棵树的数据结构是什么呢?
先来了解一下树的节点,树的节点可以主要分为叶子节点和非叶子节点两类
下面时Antlr4 tree文件夹中的类和接口
(2)来看一下类的继承关系
(3)各个类的解释如下
Tree 接口,是所有节点的接口。它定义了获取父节点,子节点,节点数据的接口
SyntaxTree 接口,增加了获取当前节点涉及到的分词范围(antlr4会先将语句分词,然后才将分词解析成树)
ParserTree 接口,增加了支持Visitor遍历树的接口
TerminalNode 接口,表示叶子节点,增加了获取当前节点的分词(叶子节点表示字符常量,或者在antlr4为文件中的lexer)
TerminalNodeImpl 类, 实现了TerminalNode接口,表示正常的叶子节点
ErrorNodeImpl类,继承TerminalNodeImpl类,表示错误的叶子节点
RuleNode 接口,非叶子节点,表示一个句子的语法, 对应antlr4文件中的parser rule
RuleContext 类,实现了RuleNode 接口
ParserRuleContext 类,在RuleContext 的基础上实现了查询子节点的方法,并且支持Listener遍历
InterpreterRuleContext 和RuleContextWithAltNum 时用于特殊用途的
在使用的过程中,我们主要使用 TerminalNodeImpl(叶子节点)和 ParserRuleContext(非叶子节点)两个类
五、Visitor遍历类
antlr4提供了visitor遍历方式,这个是典型的访问者设计模式。访问者为每个不同类型的节点,实现不同的访问方法。而每个节点实现统一的访问入口
ParserTree接口代表着节点,它的同意访问入口是accept方法。
T accept(ParseTreeVisitor<? extends T> var1);
public interface ParseTree extends SyntaxTree {
ParseTree getParent();
ParseTree getChild(int var1);
void setParent(RuleContext var1);
<T> T accept(ParseTreeVisitor<? extends T> var1);
String getText();
String toStringTree(Parser var1);
}
ParserTree的子类会实现accept方法,比如叶子节点TerminnalNodeImpl,它是调用了访问者的visitTerminal方法,非叶子节点,调用了访问者的visitChildren方法。
public class TerminalNodeImpl implements TerminalNode {
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
return visitor.visitTerminal(this);
}
}
public class RuleContext implements RuleNode {
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
return visitor.visitChildren(this);
}
}
ParserTreeVisitor 接口,定义了对于不同类型节点的访问接口。
public interface ParseTreeVisitor<T> {
//访问数据节点,不区分类型
T visit(ParseTree var1);
//访问非叶子节点
T visitChildren(RuleNode var1);
//访问叶子节点
T visitTerminal(TerminalNode var1);
//访问出错节点
T visitErrorNode(ErrorNode var1);
}
AbstractParserTreeVistor 类实现了上述接口,它的visit方法,只是简单的调用了节点的accept方法
public abstract class AbstractParseTreeVisitor<T> implements ParseTreeVisitor<T> {
public AbstractParseTreeVisitor() {
}
//节点的accpet方法会根据节点的类型,调用visitor的不同方法
public T visit(ParseTree tree) {
return tree.accept(this);
}
//对于非叶子节点,会遍历各个节点,然后将结果聚合整理。访问非叶子节点涉及到递归,它是依照深度优先遍历
public T visitChildren(RuleNode node) {
//生成默认值
T result = this.defaultResult();
int n = node.getChildCount();
//检测是否继续遍历子节点 this.shouldVisitNextChild(node, result)
for(int i = 0; i < n && this.shouldVisitNextChild(node, result); ++i) {
//获取子节点
ParseTree c = node.getChild(i);
//遍历子节点,返回子节点的结果
T childResult = c.accept(this);
//合并子节点的结果
result = this.aggregateResult(result, childResult);
}
return result;
}
//对于叶子节点和出错节点,仅仅是返回一个默认值
public T visitTerminal(TerminalNode node) {
return this.defaultResult();
}
public T visitErrorNode(ErrorNode node) {
return this.defaultResult();
}
protected T defaultResult() {
return null;
}
//合并结果,这里只是返回子节点的结果
protected T aggregateResult(T aggregate, T nextResult) {
return nextResult;
}
//默认继续访问
protected boolean shouldVisitNextChild(RuleNode node, T currentResult) {
return true;
}
}