• Antlr4 快速入门 - 编写语法解析器

    Antlr全称(ANother Tool for Language Recognition)，Antlr4是一款强大的语法分析器生成工具，推特，Haddop，Oracle等各大知名公司在用到了Antlr来构建自己的语言处理类项目。

    一门语言的正式描述称为语法(grammar)，Antlr可以为语言生成一个词法分析器，并且自动建立语法分析树，也能自动生成树的遍历器，然后我们就可以访问树的节点，执行自定义业务逻辑代码。

    本文主要是介绍Antlr4的使用，因此不过多的介绍其特性和各种使用方式，以简单的Demo来了解下它的功能。

    基本概念

    词法分析

    词法分析也称为分词，此阶段从左向右扫描源文件，将其字符流分割成一个个的词(token) 。所谓 token ，就是源文件中不可再进一步分割的一串字符，类似于英语中单词，或汉语中的词。

    • 语法中一般有多种字符组合起来的规则，有意义的字符组合一般为(Token)
    • 将文本转换为Token的程序称为词法分析器(Lexier)，过程称为词法分析(Lexical analysis) 

    语法分析

    • 词法分析完成后，字符流就被转换为 token 流了，接下来根据语言的语法规则来解析这个token 流，被称为语法分析。
    • 语法分析的过程就是不断的将语法规则应用于源程序，将源程序解析成一颗抽象语法树(parser tree)，该树记录了语法分析器识别语句结构的过程；

    入门Antlr

    以上词法分析和语法分析的过程，在实际使用antlr的过程都不需要关心，只需要进行定义语法规则，以及处理最后的语法分析树即可。

    环境配置

    有两种方式可以快速的跑起来Demo，命令行或者IDE，不过由于命令行当前默认需要JDK 11，可能大部分人不支持这个版本，还有一些额外的配置。

    antlr 在 4.10仍然支持JDK 1.8，在4.10.1之后需要JDK11。

    我们直接使用Idea自带的插件来完成Demo；

    安装antlr4的插件； 

    Idea插件使用

    新建一个Expr.g4文件，记得文件名要和里面定义的语法规则名称保持一致。 

    1. grammar Expr;
    2. prog:	expr EOF ;
    3. expr:	expr ('*'|'/') expr
    4.     |	expr ('+'|'-') expr
    5.     |	INT
    6.     |	'(' expr ')'
    7.     ;
    8. NEWLINE : [\r\n]+ -> skip;
    9. INT     : [0-9]+ ;
    10. 复制代码

    在文件目标规则上右键测试，Antlr4帮我们生成了最终的分析树： 

     

    Java API使用

    1. 引入Pom

    1.     <dependency>
    2.             <groupId>org.antlr</groupId>
    3.             <artifactId>antlr4</artifactId>
    4.             <version>4.10.1</version>
    5.         </dependency>
    6. 复制代码

    2. 插件生成Java代码

    把生成的文件拷贝到自己的包下：

    其中文件的含义：

    • ExprParser 包含语法分析器的定义，专门用来识别我们的语言。
    • ExprLexer 词法分析器的定义，将输入字符分解为词汇符号；
    • ExprLexer.tokens antlr4会将我们定义的词法符号指定一个数字类型，然后将对应的关系存储在这个文件中，一般来说我们用不到，高阶选手可能会用到。
    • ExprListener antlr4在遍历语法树的时候，遍历器会触发一系列的事件，通知我们的监听器；ExprListener是监听器的接口定义 ExprBaseListener是监听器的空实现。
    • ExprVisitor 如果我们想要自己显示的自定义遍历语法树，可以使用Visitor来遍历树，ExprBaseVistor是默认的空实现。

    3. 使用生成代码

    1. package me.aihe.bizim.expr;
    2.  
    3. import me.aihe.bizim.expr.ExprParser.ProgContext;
    4. import org.antlr.v4.runtime.CharStreams;
    5. import org.antlr.v4.runtime.CodePointCharStream;
    6. import org.antlr.v4.runtime.CommonTokenStream;
    7. import org.antlr.v4.runtime.tree.ParseTreeWalker;
    8.  
    9. public class ExprDemo {
    10.  
    11.     public static void main(String[] args) {
    12.         // 构建字符流
    13.         CodePointCharStream charStream = CharStreams.fromString("1+2+3*4");
    14.  
    15.         // 从字符流分析词法， 解析为token
    16.         ExprLexer lexer = new ExprLexer(charStream);
    17.  
    18.         // 从token进行分析
    19.         ExprParser parser = new ExprParser(new CommonTokenStream( lexer) );
    20.  
    21.         // 使用监听器，遍历语法树，根据语法定义，prog为语法树的根节点
    22.         ProgContext prog = parser.prog();
    23.         ParseTreeWalker walker = new ParseTreeWalker();
    24.         walker.walk( new ExprBaseListener(), prog );
    25.  
    26.         // 使用visitor，生成自定义的对象
    27.         Object accept = prog.accept(new ExprBaseVisitor<>());
    28.  
    29.  
    30.         // 打印生成的语法树
    31.         System.out.println( prog.toStringTree(parser));
    32.  
    33.     }
    34.  
    35. }
    36.  
    37.  
    38. 复制代码

    4. 编写自定义的业务逻辑

    通过antlr4的API，我们可以识别定义语言的语法树，但是如何做自定义的处理呢，基于上述的demo，我们实现自己的visior用于构建一个计数器的实现。

    在真正实现之前，我们需要将语法重新区分一下不同的分支，方便逻辑处理：

    1. grammar Expr;
    2. prog:	expr EOF ;
    3. expr:	expr ('*'|'/') expr  #MultiOrDiv
    4.     |	expr ('+'|'-') expr  #AddOrSub
    5.     |	INT     #Lieteral
    6.     |	'(' expr ')'   #Single
    7.     ;
    8. NEWLINE : [\r\n]+ -> skip;
    9. INT     : [0-9]+ ;
    10. 复制代码
    1. package me.aihe.bizim.expr;
    2.  
    3. import java.util.Objects;
    4.  
    5. import me.aihe.bizim.expr.ExprParser.AddOrSubContext;
    6. import me.aihe.bizim.expr.ExprParser.ExprContext;
    7. import me.aihe.bizim.expr.ExprParser.LieteralContext;
    8. import me.aihe.bizim.expr.ExprParser.MultiOrDivContext;
    9. import me.aihe.bizim.expr.ExprParser.ProgContext;
    10. import me.aihe.bizim.expr.ExprParser.SingleContext;
    11.  
    12. public class EvalExprVisitor extends ExprBaseVisitor<Integer>{
    13.  
    14.     /**
    15.      * 入口处调用
    16.      * @param ctx the parse tree
    17.      * @return
    18.      */
    19.     @Override
    20.     public Integer visitProg(ProgContext ctx) {
    21.         ExprContext expr = ctx.expr();
    22.         return visit(expr);
    23.     }
    24.  
    25.     /**
    26.      * expr:	expr ('*'|'/') expr
    27.      *     |	expr ('+'|'-') expr
    28.      *     |	INT
    29.      *     |	'(' expr ')'
    30.      * @param ctx the parse tree
    31.      * @return
    32.      */
    34.     /**
    35.      * expr ('*'|'/') expr
    36.      */
    37.     @Override
    38.     public Integer visitMultiOrDiv(MultiOrDivContext ctx) {
    39.         Integer op1 = visit(ctx.expr(0));
    40.         Integer op2 = visit(ctx.expr(1));
    41.  
    42.         String operator = ctx.getChild(1).getText();
    43.         if (Objects.equals(operator, "*")){
    44.             return op1 * op2;
    45.         }
    46.  
    47.         if (Objects.equals(operator, "/")){
    48.             return op1 / op2;
    49.         }
    50.  
    51.         return 0;
    52.     }
    53.  
    54.     /**
    55.      * expr ('+'|'-') expr
    56.      */
    57.     @Override
    58.     public Integer visitAddOrSub(AddOrSubContext ctx) {
    59.         Integer op1 = visit(ctx.expr(0));
    60.         Integer op2 = visit(ctx.expr(1));
    61.  
    62.         String operator = ctx.getChild(1).getText();
    63.         if (Objects.equals(operator, "+")){
    64.             return op1 + op2;
    65.         }
    66.  
    67.         if (Objects.equals(operator, "-")){
    68.             return op1 - op2;
    69.         }
    70.  
    71.         return 0;
    72.     }
    73.  
    74.     /**
    75.      *
    76.      * @param ctx the parse tree
    77.      * @return
    78.      */
    79.     @Override
    80.     public Integer visitSingle(SingleContext ctx) {
    81.         return visit(ctx);
    82.     }
    83.  
    84.     /**
    85.      * INT
    86.      * @return
    87.      */
    88.     @Override
    89.     public Integer visitLieteral(LieteralContext ctx) {
    90.         return Integer.valueOf(ctx.INT().getText());
    91.     }
    92. }
    93.  
    94. 复制代码

    5. 验证程序

    符合预期，这样我们自定义的计数器解析程序就处理好了；

    1. import java.util.Arrays;
    2. import java.util.List;
    3. import java.util.Objects;
    4.  
    5. import me.aihe.bizim.expr.ExprParser.ProgContext;
    6. import org.antlr.v4.runtime.CharStreams;
    7. import org.antlr.v4.runtime.CodePointCharStream;
    8. import org.antlr.v4.runtime.CommonTokenStream;
    9. import org.springframework.util.Assert;
    10.  
    11. public class ExprDemo {
    12.  
    13.     public static void main(String[] args) {
    14.  
    15.         List<String> testSet = Arrays.asList(
    16.             "1+2",
    17.             "1+2+3*4",
    18.             "3/3",
    19.             "10/2",
    20.             "5*5+10+5*5"
    21.         );
    22.  
    23.         List<Integer> res = Arrays.asList(
    24.             3,15,1,5,60
    25.         );
    26.  
    27.         for (int i = 0; i < testSet.size(); i++) {
    28.             // 构建字符流
    29.             CodePointCharStream charStream = CharStreams.fromString(testSet.get(i));
    30.  
    31.             // 从字符流分析词法， 解析为token
    32.             ExprLexer lexer = new ExprLexer(charStream);
    33.  
    34.             // 从token进行分析
    35.             ExprParser parser = new ExprParser(new CommonTokenStream( lexer) );
    36.  
    37.             // 使用监听器，遍历语法树，根据语法定义，prog为语法树的根节点
    38.             ProgContext prog = parser.prog();
    39.  
    40.  
    41.             // 使用visitor，生成自定义的对象
    42.             Integer integer = prog.accept(new EvalExprVisitor());
    43.             System.out.println(integer);
    44.             Assert.isTrue(Objects.equals(integer, res.get(i)),"");
    45.         }
    46.     }
    47.  
    48. }
    49.  
    50. 复制代码

    6. 生成调用图

    借用一个辅助工具dot语言，用来生成各种自定义图形的，基于上述的语法树监听器，我们构建自己的执行程序，然后查看真实的调用过程。

    1. package me.aihe.bizim.expr;
    2.  
    3. import java.util.List;
    4. import java.util.Set;
    5. import java.util.Stack;
    6.  
    7. import me.aihe.bizim.expr.ExprParser.ProgContext;
    8. import org.antlr.v4.runtime.ParserRuleContext;
    9. import org.antlr.v4.runtime.misc.MultiMap;
    10. import org.antlr.v4.runtime.misc.OrderedHashSet;
    11.  
    12. public class EvalExprListener extends ExprBaseListener {
    13.  
    14.     private Graph graph = new Graph();
    15.     Stack<String> current = new Stack<>();
    16.  
    17.     String prefix = "exp_";
    18.  
    19.  
    20.  
    21.     @Override
    22.     public void enterEveryRule(ParserRuleContext ctx) {
    23.         if (ctx instanceof ProgContext){
    24.             return;
    25.         }
    26.  
    27.         // 生成唯一的节点标识
    28.         String n = prefix + System.identityHashCode(ctx);
    29.         String node = n + String.format("[label=<%s>]",ctx.getText());
    30.         graph.nodes.add(node);
    31.  
    32.         if (!current.empty()){
    33.             graph.edge( current.peek(), n );
    34.         }
    35.  
    36.         current.push(n);
    37.     }
    38.  
    39.     @Override
    40.     public void exitEveryRule(ParserRuleContext ctx) {
    41.         if (ctx instanceof ProgContext){
    42.             return;
    43.         }
    44.         current.pop();
    45.     }
    46.  
    47.     public String toDot(){
    48.         return graph.toDot();
    49.     }
    50.  
    51.  
    52.     static class Graph {
    53.         Set<String> nodes = new OrderedHashSet<>();
    54.         MultiMap<String, String> edges = new MultiMap<>();
    55.  
    56.  
    57.         public void edge(String source, String target) {
    58.             if (source == null || target == null){
    59.                 return;
    60.             }
    61.             edges.map(source, target);
    62.         }
    63.  
    64.         public String toDot() {
    65.             StringBuffer sb = new StringBuffer();
    66.             sb.append("digraph G { \n");
    67.             sb.append("node[shape=plaintext,style=filled];graph[splines=ortho];\n");
    68.  
    69.             // 声明节点
    70.             for (String node : nodes) {
    71.                 sb.append(node).append(";");
    72.                 sb.append("\n");
    73.             }
    74.  
    75.             sb.append("\n");
    76.  
    77.             for (String source : edges.keySet()) {
    78.                 List<String> targets = edges.get(source);
    79.                 for (String target : targets) {
    80.                     sb.append(" ")
    81.                         .append(source)
    82.                         .append(" -> ")
    83.                         .append(target).append("\n");
    84.                 }
    85.             }
    86.  
    87.             sb.append("}\n");
    88.             return sb.toString();
    89.         }
    90.  
    91.     }
    92. }
    93.  
    94. 复制代码

    使用监听器：

    1. CodePointCharStream charStream = CharStreams.fromString(testSet.get(i));
    2.  
    3.             // 从字符流分析词法， 解析为token
    4.             ExprLexer lexer = new ExprLexer(charStream);
    5.  
    6.             // 从token进行分析
    7.             ExprParser parser = new ExprParser(new CommonTokenStream( lexer) );
    8.  
    9.             // 使用监听器，遍历语法树，根据语法定义，prog为语法树的根节点
    10.             ProgContext prog = parser.prog();
    11.  
    12.  
    13.             // 使用visitor，生成自定义的对象
    14.             Integer integer = prog.accept(new EvalExprVisitor());
    15.             System.out.println(integer);
    16.             Assert.isTrue(Objects.equals(integer, res.get(i)),"");
    17.  
    18.             ParseTreeWalker walker = new ParseTreeWalker();
    19.  
    20.             EvalExprListener listener = new EvalExprListener();
    21.             walker.walk(listener, prog );
    22.             System.out.println(listener.toDot());
    23. 复制代码

    5*5+10+5*5 生成结果：

    1. digraph G { 
    2. node[shape=plaintext,style=filled];graph[splines=ortho];
    3. exp_2085857771[label=<5*5+10+5*5>];
    4. exp_248609774[label=<5*5+10>];
    5. exp_708049632[label=<5*5>];
    6. exp_1887400018[label=<5>];
    7. exp_285377351[label=<5>];
    8. exp_344560770[label=<10>];
    9. exp_559450121[label=<5*5>];
    10. exp_716083600[label=<5>];
    11. exp_791885625[label=<5>];
    12.  
    13.  exp_2085857771 -> exp_248609774
    14.  exp_2085857771 -> exp_559450121
    15.  exp_248609774 -> exp_708049632
    16.  exp_248609774 -> exp_344560770
    17.  exp_708049632 -> exp_1887400018
    18.  exp_708049632 -> exp_285377351
    19.  exp_559450121 -> exp_716083600
    20.  exp_559450121 -> exp_791885625
    21. }
    22. 复制代码

    在dot语言解析网站上贴下生成的代码： dreampuf.github.io/GraphvizOnl…

    7. Java代码生成Dot图

    或者直接用Java代码生成对应的SVG图也是可以的：仍然使用上述监听器。

    下载plantuml：plantuml.com/zh/download graphviz配置：plantuml.com/zh/graphviz…

    • 首先在机器上安装graphviz；
    • 验证plantuml支持点图，java -jar plantuml.jar -testdot
    • 集成点图的pom，然后输出图片。

    Java引入依赖：

    1.     <dependency>
    2.             <groupId>net.sourceforge.plantuml</groupId>
    3.             <artifactId>plantuml</artifactId>
    4.             <version>1.2022.13</version>
    5.         </dependency>
    6. 复制代码

    使用Java生成对应的点图：

    1.  
    2. public class Demo {
    3.     public static void main(String[] args) throws IOException {
    4.         FileFormat gif = FileFormat.valueOf("SVG");
    5.         StringBuffer sb = new StringBuffer();
    6.         // 注意 digraph g {的后面不要有空格
    7.         sb.append("@startuml\n"
    8.             + "digraph g {\n"
    9.             + "node[shape=plaintext,style=filled];graph[splines=ortho];\n"
    10.             + "exp_2085857771[label=<5*5+10+5*5>];\n"
    11.             + "exp_248609774[label=<5*5+10>];\n"
    12.             + "exp_708049632[label=<5*5>];\n"
    13.             + "exp_1887400018[label=<5>];\n"
    14.             + "exp_285377351[label=<5>];\n"
    15.             + "exp_344560770[label=<10>];\n"
    16.             + "exp_559450121[label=<5*5>];\n"
    17.             + "exp_716083600[label=<5>];\n"
    18.             + "exp_791885625[label=<5>];\n"
    19.             + "\n"
    20.             + " exp_2085857771 -> exp_248609774\n"
    21.             + " exp_2085857771 -> exp_559450121\n"
    22.             + " exp_248609774 -> exp_708049632\n"
    23.             + " exp_248609774 -> exp_344560770\n"
    24.             + " exp_708049632 -> exp_1887400018\n"
    25.             + " exp_708049632 -> exp_285377351\n"
    26.             + " exp_559450121 -> exp_716083600\n"
    27.             + " exp_559450121 -> exp_791885625\n"
    28.             + "}\n"
    29.             + "@enduml");
    30.  
    31.         String str = sb.toString();
    32.         System.out.println(str);
    33.         SourceStringReader dot = new SourceStringReader(str);
    34.         FileOutputStream os = new FileOutputStream(new File("result.svg"));
    35.         dot.outputImage(os, new FileFormatOption(gif));
    36.         os.flush();
    37.  
    38.     }
    39. }
    40. 复制代码

    8. 添加错误监听器

    1. // 可以在识别到错误的时候，抛出异常终止进行
    2. parser.addErrorListener( new BaseErrorListener());
    3. 复制代码

    自定义语法

    如果说想要自定义一些语言类应用，可以参考antlr4的lab网站，内置了当前主流的语言语法结构。

    lab.antlr.org/

    比如URL语法，以及JSON，CSV，DOT、SQL等语言的解析器；

    总结

    1、Antlr4是一种语法分析器的 生成器，帮我们屏蔽了词法分析和语法分析的过程，直接生成出对应的语法分析树。 基于语法分析树，我们可以构建自己的语言类应用；

    2、Idea工具可以直接安装Antlr4的插件，可以帮我们检验自定义的语法特性，并且可以生成对应的Java基础类。

    3、通过生成的Java基础类，配合Antlr4的API，可以快速完成一个语言类的应用。

    参考：

  • 相关阅读:
    冰冰学习笔记：内存地址空间
    入门力扣自学笔记109 C++ （题目编号1161）
    docker下的onlyoffice安装（for seafile）
    Android显示系统-GraphicBuffer和Gralloc分析
    #13Maven打包生成MD5校验文件的两种方式
    ENVI IDL:对于GEOTIFF结构体的说明
    低代码平台那些事儿
    redis和nacos的安装
    Ansible之Ansible Tower使用User和Team管理访问权限的笔记
    java8---1、为什么要用lambda表达式？
  • 原文地址：https://blog.csdn.net/BASK2311/article/details/128215337