ANTLR学习（三）antlr的功能

最新推荐文章于 2024-04-09 21:04:24 发布
最新推荐文章于 2024-04-09 21:04:24 发布
阅读量640 收藏 7
点赞数
分类专栏： antlr学习 文章标签： 学习 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52224421/article/details/125031917
版权

文章目录

算数表达式语言

匹配算数表达式的语言

我们的表达式语言组成的程序就是一系列语句，每个语句都由换行符终止，一个语句可以是一个表达式、一个赋值语句或者是一个空行。

语法

//Expr.g4
grammar Expr;

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

stat:   expr NEWLINE                
    |   ID '=' expr NEWLINE        
    |   NEWLINE                   
    ;

expr:   expr ('*'|'/') expr   
    |   expr ('+'|'-') expr   
    |   INT                    
    |   ID                    
    |   '(' expr ')'         
    ;

ID  :   [a-zA-Z]+ ;      // match identifiers <label id="code.tour.expr.3"/>
INT :   [0-9]+ ;         // match integers
NEWLINE:'\r'? '\n' ;     // return newlines to parser (is end-statement signal)
WS  :   [ \t]+ -> skip ; // toss out whitespace
  • 语法分析器的规则以小写字母开头
  • 词法分析器的规则以大写字母开头
  • 使用|来分割同一个语言规则的若干备选分支，使用圆括号吧一些符号组成子规则,('*' | '/')匹配一个乘法符号或除法符号

antlr4的最重要功能之一就是它在大部分情况下能够处理左递归规则，详细参考左递归

使用上面的Expr.g4文件做一个测试
antlr4 Expr.g4
javac Expr*.java
grun Expr prog -gui t.expr
运行结果
在这里插入图片描述
相应源码也可以在https://pragprog.com/titles/tpantlr2/the-definitive-antlr-4-reference/上下载

//ExprJoyRide.java
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.*;
import java.io.FileInputStream;
import java.io.InputStream;
public class ExprJoyRide {
    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); 
        ExprLexer lexer = new ExprLexer(input); 
        CommonTokenStream tokens = new CommonTokenStream(lexer); 
        ExprParser parser = new ExprParser(tokens); 
        ParseTree tree = parser.prog(); // 从parse规则开始进行语法分析
        System.out.println(tree.toStringTree(parser)); //以文本形式打印树
    }
}

javac ExprJoyRide.java Expr*.java
java ExprJoyRide t.expr
运行结果
在这里插入图片描述

语法导入

//CommonLexerRules.g4
lexer grammar CommonLexerRules; // note "lexer grammar"

ID  :   [a-zA-Z]+ ;      // match identifiers
INT :   [0-9]+ ;         // match integers
NEWLINE:'\r'? '\n' ;     // return newlines to parser (end-statement signal)
WS  :   [ \t]+ -> skip ; // toss out whitespace


//LabeledExpr.g4
grammar LabeledExpr; // rename to distinguish from Expr.g4

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

能不能将CommonLexerRules.g4中的词法规则重构进LabeledExpr.g4呢？
答案是可以的

grammar LabeledExpr; // rename to distinguish from Expr.g4
import CommonLexerRules;//添加的代码

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
    ;

测试
在这里插入图片描述

处理错误输入

在这里插入图片描述
可以看到，语法分析器报错并从错误中恢复
在这里插入图片描述
在这里插入图片描述
语法分析器会在错误节点标红

使用访问者模式构建一个计算器

//LabeledExpr.g4
grammar LabeledExpr; // rename to distinguish from Expr.g4

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


//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);
        LabeledExprParser parser = new LabeledExprParser(tokens);
        ParseTree tree = parser.prog(); // parse

        EvalVisitor eval = new EvalVisitor();
        eval.visit(tree);
    }
}

命令行执行
antlr4 -no-listener -visitor LabeledExpr.g4

import java.util.HashMap;
import java.util.Map;

public class EvalVisitor extends LabeledExprBaseVisitor<Integer> {
    /** "memory" for our calculator; variable/value pairs go here */
    Map<String, Integer> memory = new HashMap<String, Integer>();

    /** ID '=' expr NEWLINE */
    @Override
    public Integer visitAssign(LabeledExprParser.AssignContext ctx) {
        String id = ctx.ID().getText();  // id is left-hand side of '='
        int value = visit(ctx.expr());   // compute value of expression on right
        memory.put(id, value);           // store it in our memory
        return value;
    }

    /** expr NEWLINE */
    @Override
    public Integer visitPrintExpr(LabeledExprParser.PrintExprContext ctx) {
        Integer value = visit(ctx.expr()); // evaluate the expr child
        System.out.println(value);         // print the result
        return 0;                          // return dummy value
    }

    /** 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));  // get value of left subexpression
        int right = visit(ctx.expr(1)); // get value of right subexpression
        if ( ctx.op.getType() == LabeledExprParser.MUL ) return left * right;
        return left / right; // must be DIV
    }

    /** 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()); // return child expr's value
    }
}

使用t.expr作为输入
javac Calc.java LabeledExpr*.java
type t.expr
在这里插入图片描述
无需再语法文件中插入Java代码编写的动作，语法文件独立于程序，具有编程语言中立性。

利用监听器构建一个翻译器

读取目标：

//Demo.java
import java.util.List;
import java.util.Map;
public class Demo {
	void f(int x, String y) { }
	int[ ] g(/*no args*/) { return null; }
	List<Map<String, Integer>>[] h() { return null; }
}

使用其中的方法签名生成一个接口，保留其中的全部空白字符和注释
想要得到：

interface IDemo {
	void f(int x,String y);
	int[ ] g(/*no args*/);
	List<Map<String, Integer>>[] h();
}

//ExtractInterfaceTool.java
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.*;

import java.io.FileInputStream;
import java.io.InputStream;

public class ExtractInterfaceTool {
    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);

        JavaLexer lexer = new JavaLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        JavaParser parser = new JavaParser(tokens);
        ParseTree tree = parser.compilationUnit(); // parse

        ParseTreeWalker walker = new ParseTreeWalker(); // create standard walker
        ExtractInterfaceListener extractor = new ExtractInterfaceListener(parser);
        walker.walk(extractor, tree); // initiate walk of tree with listener
    }
}

操作
antlr4 Java.g4
java org.antlr.v4.Tool Java.g4
javac Java*.java Extract*.java
java ExtractInterfaceTool Demo.java

结果：
在这里插入图片描述
成功

如何将动作直接嵌入语法文件

在语法中嵌入任意动作

//t.rows文件
parrt	Terence Parr	101
tombu	Tom Burns	020
bke	Kevin Edgar	008

//Rows.g4
grammar Rows;

@parser::members { // add members to generated RowsParser
    int col;
    public RowsParser(TokenStream input, int col) { // custom constructor
        this(input);
        this.col = col;
    }
}

file: (row NL)+ ;

row
locals [int i=0]
    : (   STUFF
          {
          $i++;
          if ( $i == col ) System.out.println($STUFF.text);
          }
      )+
    ;

TAB  :  '\t' -> skip ;   // match but don't pass to the parser
NL   :  '\r'? '\n' ;     // match and pass to the parser
STUFF:  ~[\t\r\n]+ ;     // match any chars except tab, newline


//Col.java
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.Token;

import java.io.FileInputStream;
import java.io.InputStream;

public class Col {
    public static void main(String[] args) throws Exception {
        ANTLRInputStream input = new ANTLRInputStream(System.in);
        RowsLexer lexer = new RowsLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        int col = Integer.valueOf(args[0]);
        RowsParser parser = new RowsParser(tokens, col); // pass column number!
        parser.setBuildParseTree(false); // don't waste time bulding a tree
        parser.file(); // parse
    }
}

操作与结果
在这里插入图片描述

使用语义判定改变语法分析过程

//t.data
2 9 10 3 1 2 3
  • 2 ➡ 匹配9，10
  • 3 ➡ 匹配1，2，3
//Data.g4
grammar Data;

file : group+ ;

group: INT sequence[$INT.int] ;

sequence[int n]
locals [int i = 1;]
     : ( {$i<=$n}? INT {$i++;} )* // match n integers
     ;
     
INT :   [0-9]+ ;             // match integers
WS  :   [ \t\n\r]+ -> skip ; // toss out all whitespace

操作与结果
在这里插入图片描述
在这里插入图片描述

词法分析特性

孤岛语法

处理相同文件中的不同格式，将模板语言表达式之外的文本按照不同的方式进行处理
例子：

//XMLLexer.g4
lexer grammar XMLLexer;

// Default "mode": Everything OUTSIDE of a tag
OPEN        :   '<'                 -> pushMode(INSIDE) ;
COMMENT     :   '<!--' .*? '-->'    -> skip ;
EntityRef   :   '&' [a-z]+ ';' ;
TEXT        :   ~('<'|'&')+ ;           // match any 16 bit char minus < and &

// ----------------- Everything INSIDE of a tag ---------------------
mode INSIDE;

CLOSE       :   '>'                 -> popMode ; // back to default mode
SLASH_CLOSE :   '/>'                -> popMode ;
EQUALS      :   '=' ;
STRING      :   '"' .*? '"' ;
SlashName   :   '/' Name ;
Name        :   ALPHA (ALPHA|DIGIT)* ;
S           :   [ \t\r\n]           -> skip ;

fragment
ALPHA       :   [a-zA-Z] ;

fragment
DIGIT       :   [0-9] ;


<tools>
	<tool name="ANTLR">A parser generator</tool>
</tools>

构建与测试
在这里插入图片描述

重写输入流

antlr4 Java.g4
javac InsertSerialID*.java Java*.java
java InsertSerialID Demo.java
在这里插入图片描述

将词法符号送入不同通道

对于大多数语法，语法分析器是可以忽略空白字符与注释，但这样同样意味着程序中将完全无法访问空白字符和注释，那么如何保留空白字符和注释呢，方法是将这些词法符号送入另外一个通道，语法分析器只处理一个通道，我们就将希望保留的符号送入其他通道，这样就可以实现对空白字符和注释的保留。
Java语法

COMMENT
    :   '/*' .*? '*/'    -> channel(HIDDEN) // match anything between /* and */
    ;
WS  :   [ \r\t\u000C\n]+ -> channel(HIDDEN)
    ;
飘渺孤鸿影@
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
antlr v4 使用指南连载5——如何编写词法定义
diefen3773的博客
12-12 167
如何编写词法定义 继上一篇文章，相信大家都明了编写词法规则的两个基本原则。那么接下来就可以开始编写词法文件了。对于计算机科学来说，很多词法规则是一致的。如标识符、数字等，它们都可以重复在多个项目中应用，这是题外话。 在词法文件中，除了词法定义之外，还有一些可选项，应该要先说明一下。匆匆一瞥，以览概貌，这是我一贯的风格。 fragment 词法片段，构成词法的元素，不是一个...
Antlr g4 入门+深入
杀神lwz的博客
07-13 7365
ANTLR 是用JAVA写的语言识别工具，它用来声明语言的语法，简称为“元语言”。 Idea中配置使用 pom.xml添加 <dependency> <groupId>org.antlr</groupId> <artifactId>antlr4-runtime</artifactId> <version>4.7</version>
【编译原理】Antlr 入门使用
最新发布
笨鸟先飞的博客
04-09 866
前面文章我们学习了编译器前端的词法和语法分析工具，本篇我们来看看如何借助 Antlr 工具，快速生成词法和语法分析代码。
【Antlr】识别常见的词法结构
九师兄
01-01 750
语法分析器通过输入的词法符号流来识别特定的语言结构词法分析器通过输入的字符流来识别特定的语言结构。词法规则以大写字母开头文法规则以小写字母开头。例如，ID是一个词法规则名，而expr是一 个文法规则名。
ANTLR4 如何编写语法文件之语法结构
SmartSi
01-04 841
一份语法由一个语法声明和紧随其后的若干规则构成
Antlr4简易快速入门
JacksonKing的专栏
04-08 2435
Antlr4简易快速入门 1. 简介 Antlr (ANother Tool for Language Recognition) 是一个强大的跨语言语法解析器，可以用来读取、处理、执行或翻译结构化文本或二进制文件。它被广泛用来构建语言，工具和框架。Antlr可以从语法上来生成一个可以构建和遍历解析树的解析器。 2. 谁在使用 Hive Spark Oracle Presto Elasticsearch 3. 常见的语法分析器 Antlr Javacc SqlParser (位于Alib
ANTLR-Mode for Emacs-开源
05-13
Emacs软件包ANTLR-Mode提供：ANTLR语法文件的语法高亮显示，自动缩进，包含规则/令牌定义和受支持的选项的菜单以及其他各种操作，例如从Emacs中运行ANTLR。
Antlr4 ---词法规则
04stone37
01-02 4823
规则存放位置  词法规则既可以和语法规则写在同一个文件{xxx}.g4，也可以单独放在词法规则文件{xxx}Lexer.g4； 匹配原则 最长匹配原则： 输入串将被最长匹配的词法规则匹配； 优先声明原则： 若输入串能同时被多个词法规则匹配，那么声明在词法文件最前面的规则生效； 解析内容  词法规则作用是将一个个字符按照定义的规则聚集成字符，主要有以下四类： 标识符： 即各类编程语言中的变量名...
antlr(3)
u014244856的博客
12-15 79
antlr
antlr 生成 java 代码_使用antlr4, 用ts/js还原protobuf生成的java代码为pb (二)
weixin_42464697的博客
02-22 355
目录:现在开始写一个简单公式计算器的parser.expr.g4grammar Expr ;prog: stat+ ;stat: expr NEWLINE # printExpr| ID '=' expr NEWLINE # assign| NEWLINE # empty;expr: expr op=(MUL|...
c语言语法（三）
lfdanding的专栏
08-14 510
今天刷c语言题的时候，在函数传递指针的问题上进行了一下思考，主要参考这篇文章http://www.cnblogs.com/nearu/archive/2009/06/08/1498918.htmlvoid GetMemory(char *p, int num) { p = (char *)malloc(sizeof(char) * num); } void Test(void) {
ANTLR3 简介及示例
03-28
NULL 博文链接：https://hellojinjie.iteye.com/blog/1197529
The Definitive ANTLR4Reference 学习笔记
12-24
The Definitive ANTLR4Reference 学习笔记 The Definitive ANTLR4Reference 学习笔记
Antlr入门介绍小demo
01-05
Antlr入门介绍小demo
antlr4权威指南
03-22
antlr4权威指南，适合想要构建自己的语言的同学，使用antlr4构建更方便
antlr权威指南
02-28
antlr是指可以根据输入自动生成语法树并可视化的显示出来的开源语法分析器。
antlr-2.7.7源码
12-22
antlr 2.7.7源码，下载自：http://repo.spring.io/plugins-release/org/antlr/com.springsource.antlr/2.7.7/
【Antlr】Antlr 孤岛语法：处理相同文件中的不同格式
九师兄
06-29 799
1.概述 ANTLR有三个与词法符号有关非常棒的特性，值得付诸笔墨。首先，我们将会尝试处理XML .这样的具有不同词法结构的输入格式 (标签内外不同)。其次，我们将会学习通过修改输入的词法符号流，在Java类中插入一个字段的方法。它将会展示，如何以最低的代价来生成和输入内容相似的输出。最后，我们将会看到ANTLR语法分析器如何忽略空白字符和注释，同时不丢弃它们。 2.孤岛语法：处理相同文件中的不同格式 迄今为止，我们看到的样例输入文件都只包含一种语言，但是事实上，有很多常见的文件格式包含多重语言。 例如，.
antlr4和antlr3的区别
09-02
ANTLR（ANother Tool for Language Recognition）是一个用于构建语法分析器的工具。ANTLR3和ANTLR4是ANTLR的两个主要版本，它们之间有几个重要的区别： 1. 语法规则定义：ANTLR3使用基于词法分析器和语法分析器的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值