Antlr入门详细教程.docx

Antlr入门详细教程.docx

《Antlr入门详细教程.docx》由会员分享，可在线阅读，更多相关《Antlr入门详细教程.docx（46页珍藏版）》请在冰豆网上搜索。

Antlr入门详细教程

一、Antlr的主要类：

　　Antlr中有主要类有两种（其实还有一种TreeLexer）

　　Lexer：

文法分析器类。

主要用于把读入的字节流根据规则分段。

既把长面条根据你要的尺寸切成一段一段：

）并不对其作任何修改。

　　Parser：

解析器类。

主要用于处理经过Lexer处理后的各段。

一些具体的操作都在这里。

　　二、Antlr文法文件形式：

　　Antlr文件是*.g形式，即以g为后缀名。

　　例如：

t.g

　　classPextendsParser；

　　startRule

　　：

  n：

NAME

　　{System.out.println（"Hithere，"+n.getText（））；}

　　；

　　classLextendsLexer；

　　//one-or-morelettersfollowedbyanewline

　　NAME：

  （'a'……'z'|'A'……'Z'）+NEWLINE

　　；

　　NEWLINE

　　：

  '\r''\n'  //DOS

　　|  '\n'       //UNIX

　　；

　　具体成分分析：

　　1、总体结构

　　ClassPextendsParser

　　ClassLextendsLexer

　　两行同JAVA继承一样，P继承Parser类；L继承Lexer类。

每个.g文件只能各有一个。

　　2、Lexer类分析

　　一般按照

　　类型名：

匹配的具体规则；

　　的形式构成。

是分隔字节流的依据。

同时可以看到里面可以互相引用。

如本例中的类型名NEWLINE出现在NEW的匹配规则中。

　　3、Parser类分析

　　一般按照

　　起始规则名：

　　规则实例名：

类型名或规则名

　　{Java语句……；}

　　；

　　……

　　的形式构成。

　起始规则名：

任意。

　　规则实例名：

就象Java中“Strings；”的s一样。

规则实例名用于在之后的JAVA语句中调用。

　　类型名或规则名：

可以是在Lexer中定义的类型名，也可以是Parser中定义的规则名。

感觉就像是int与Integer的区别。

　　Java语句：

指当满足当前规则时所执行的语句。

Antlr会自动嵌入生成的java类中。

　　三、生成Java类

　　1、从www.antlr.org上下载antlr-x.x.x.jar

　　2、配置环境变量：

classpath=.；x：

\jdk\lib\tools.jar；x：

\antlr-x.x.x.jar

　　3、在t.g所在目录下执行：

　　javaantlr.Toolt.g

　　会在当前目录下生成如下文件：

　　L.java：

Lexer文法分析器java类。

　　P.java：

Parser解析器java类。

　　PTokenTypes.java：

Lexer中定义的类型具体化，供Parser解析器调用。

　　PTokenTypes.txt：

当外部的（如t2.g）要调用当前的类型或规则时要用到本文件。

　　四、执行

　　1、编写Main类

　　importjava.io.*；

　　classMain{

　　publicstaticvoidmain（String[]args）{

　　try{

　　Llexer=newL（newDataInputStream（System.in））；

　　Pparser=newP（lexer）；

　　parser.startRule（）；

　　}catch（Exceptione）{

　　System.err.println（"exception：

"+e）；

　　}

　　2、执行

　　c：

\>javac*.java

　　c：

\>javaMain

　　Terence

　　^Z

　　Hithere，Terence

　　c：

\>

antlr入门教程1

一、Antlr的主要类：

Antlr中有主要类有两种（其实还有一种TreeLexer）

Lexer:

文法分析器类。

主要用于把读入的字节流根据规则分段。

既把长面条根据你要的尺寸切成一段一段：

）并不对其作任何修改。

Parser:

解析器类。

主要用于处理经过Lexer处理后的各段。

一些具体的操作都在这里。

二、Antlr文法文件形式：

Antlr文件是*.g形式，即以g为后缀名。

例如：

t.g

classPextendsParser;

startRule

:

n:

NAME

{System.out.println（"Hithere,"+n.getText（））;}

;

classLextendsLexer;

//one-or-morelettersfollowedbyanewline

NAME:

（'a'..'z'|'A'..'Z'）+NEWLINE

;

NEWLINE

:

'\r''\n'//DOS

|'\n'//UNIX

;

具体成分分析：

1、总体结构

ClassPextendsParser

ClassLextendsLexer

两行同JAVA继承一样，P继承Parser类；L继承Lexer类。

每个.g文件只能各有一个。

2、Lexer类分析

一般按照

类型名：

    匹配的具体规则

    ；

的形式构成。

是分隔字节流的依据。

同时可以看到里面可以互相引用。

如本例中的类型名NEWLINE出现在NEW的匹配规则中。

3、Parser类分析

一般按照

起始规则名：

规则实例名：

类型名或规则名

{Java语句。

。

。

；}

；

。

。

。

。

。

。

。

。

。

的形式构成。

起始规则名：

任意。

规则实例名：

就象Java中“Strings；”的s一样。

规则实例名用于在之后的JAVA语句中调用。

类型名或规则名：

可以是在Lexer中定义的类型名，也可以是Parser中定义的规则名。

感觉就像是int与Integer的区别。

Java语句：

指当满足当前规则时所执行的语句。

Antlr会自动嵌入生成的java类中。

三、生成Java类

1、从[url]www.antlr.org[/url]上下载antlr-x.x.x.jar

2、配置环境变量：

classpath=.;x:

\jdk\lib\tools.jar;x:

\antlr-x.x.x.jar

3、在t.g所在目录下执行：

javaantlr.Toolt.g

会在当前目录下生成如下文件：

L.java：

Lexer文法分析器java类。

P.java：

Parser解析器java类。

PTokenTypes.java：

Lexer中定义的类型具体化，供Parser解析器调用。

PTokenTypes.txt：

当外部的（如t2.g）要调用当前的类型或规则时要用到本文件。

四、执行

1、编写Main类

importjava.io.*;

     classMain{

publicstaticvoidmain（String[]args）{

try{

Llexer=newL（newDataInputStream（System.in））;

Pparser=newP（lexer）;parser.startRule（）;

}catch（Exceptione）

{

System.err.println（"exception:

"+e）;

}

}

}

2、执行

c:

\>javac*.java

c:

\>javaMain

Terence

^Z

Hithere,Terence

c:

\>

本文作者kingchou是CowNew开源团队SQL解析引擎项目组负责人。

Antlr入门详细教程

一、Antlr的主要类：

　　Antlr中有主要类有两种（其实还有一种TreeLexer）

　　Lexer：

文法分析器类。

主要用于把读入的字节流根据规则分段。

既把长面条根据你要的尺寸切成一段一段：

）并不对其作任何修改。

　　Parser：

解析器类。

主要用于处理经过Lexer处理后的各段。

一些具体的操作都在这里。

　　二、Antlr文法文件形式：

　　Antlr文件是*.g形式，即以g为后缀名。

　　例如：

t.g

　　classPextendsParser；

　　startRule

　　：

  n：

NAME

　　{System.out.println（"Hithere，"+n.getText（））；}

　　；

　　classLextendsLexer；

　　//one-or-morelettersfollowedbyanewline

　　NAME：

  （'a'……'z'|'A'……'Z'）+NEWLINE

　　；

　　NEWLINE

　　：

  '\r''\n'  //DOS

　　|  '\n'       //UNIX

　　；

　　具体成分分析：

　　1、总体结构

　　ClassPextendsParser

　　ClassLextendsLexer

　　两行同JAVA继承一样，P继承Parser类；L继承Lexer类。

每个.g文件只能各有一个。

　　2、Lexer类分析

　　一般按照

　　类型名：

匹配的具体规则；

　　的形式构成。

是分隔字节流的依据。

同时可以看到里面可以互相引用。

如本例中的类型名NEWLINE出现在NEW的匹配规则中。

　　3、Parser类分析

　　一般按照

　　起始规则名：

　　规则实例名：

类型名或规则名

　　{Java语句……；}

　　；

　　……

　　的形式构成。

　起始规则名：

任意。

　　规则实例名：

就象Java中“Strings；”的s一样。

规则实例名用于在之后的JAVA语句中调用。

　　类型名或规则名：

可以是在Lexer中定义的类型名，也可以是Parser中定义的规则名。

感觉就像是int与Integer的区别。

　　Java语句：

指当满足当前规则时所执行的语句。

Antlr会自动嵌入生成的java类中。

　　三、生成Java类

　　1、从www.antlr.org上下载antlr-x.x.x.jar

　　2、配置环境变量：

classpath=.；x：

\jdk\lib\tools.jar；x：

\antlr-x.x.x.jar

　　3、在t.g所在目录下执行：

　　javaantlr.Toolt.g

　　会在当前目录下生成如下文件：

　　L.java：

Lexer文法分析器java类。

　　P.java：

Parser解析器java类。

　　PTokenTypes.java：

Lexer中定义的类型具体化，供Parser解析器调用。

　　PTokenTypes.txt：

当外部的（如t2.g）要调用当前的类型或规则时要用到本文件。

　　四、执行

　　1、编写Main类

　　importjava.io.*；

　　classMain{

　　publicstaticvoidmain（String[]args）{

　　try{

　　Llexer=newL（newDataInputStream（System.in））；

　　Pparser=newP（lexer）；

　　parser.startRule（）；

　　}catch（Exceptione）{

　　System.err.println（"exception：

"+e）；

　　}

　　2、执行

　　c：

\>javac*.java

　　c：

\>javaMain

　　Terence

　　^Z

　　Hithere，Terence

　　c：

\>

《探索Antlr》是两年前写的一篇文章，如今，Antlr3.0已经发布了，有了一些变化，为了反映这些变化，我决定重写这篇《探索Antlr》。

探索Antlr（Antlr3.0更新版） 

简介

Antlr（ANotherToolforLanguageRecognition）是一个工具，它为我们构造自己的识别器（recognizers）、编译器（compiler）和转换器（translators）提供了一个基础。

通过定义自己的语言规则，Antlr可以为我们生成相应的语言解析器，这样便可以省却了自己全手工打造的劳苦。

目标

如同程序设计语言入门大多采用“HelloWorld”一样，编译领域的入门往往选择计算器。

而这里迈出的第一步更为简单：

一个只能计算两个数相加的计算器，也就是说，它可以计算“1+1”。

基础知识

先来考虑一下如何下手，如果你曾经接受过编译原理的教育，权当忆苦思甜了。

这个计算器工作的前提是有一个需要计算的东西，不管我们是以文件的形式提供，还是手工输入，至少我们可以让我们的计算器知道“1+1”的存在。

有了输入之后，我们要先检查输入的正确性，只有对正确的输入进行计算才是有意义的。

如同写文章有形式和内容之分，这里的检查也要细分一下，率先完成的检查当然是面子功夫——形式上的东西，看看是否有错别字的存在，我们要做的是数值相加，结果人家给出了一个字母，这肯定不是我们希望得到的，所以我们有权力拒绝这个不合法的东西。

对于程序员来说，如果在自己的程序里写了一个语言不接受的标识符，比如在Java里用“123r”做标识符，那编译器肯定会罢工，拒绝让程序通过编译的。

在编译原理里面，这个过程叫做词法分析。

在我们的计算器中，我们只接受整数和加号，其它的一概不理。

这里我们说的是“整数”，而非“1”、“2”……，对我们来说，它们代表着同一类的东西，编译原理教导我们把这这种东西叫做token，那些数字对我们来说，都是一样的token，不同的仅仅是它们的值而已。

形式说得过去并不代表内容就可以接受，南北朝时期许多骈体文让我们看到了隐藏在华丽的外表下的空虚灵魂。

你可以说“我吃饭”，如果说“饭吃我”，除非是在练习反正话的场合，否则没有人会认为它是有意义的，因为显然这不是我们习惯的主谓宾结构。

只有在闯过了词法分析的关口，才能到达这里，在编译原理里面，我们把这个阶段叫做语法分析。

如果说词法分析阶段的输入是字符流的话，那么语法分析阶段的输入就是token流——词法分析的输出。

我们这里接受的合法语法是“整数加号整数”。

编写语法文件

好了，制订好自己的语言规则之后，我们需要以Antlr的语言把它描述出来。

下面便是以Antlr的语言描述的语法：

grammarCalculator;

expr:

  INTPLUSINT;

PLUS :

'+';

INT  :

（'0'..'9'）+;

Antlr的语法文件通常会保存在一个“.g”的文件中，我们的语法文件叫做“Caculator.g”。

我们来看看这里的定义：

expr:

  INTPLUSINT;

这条语句定义了expr，它等价于“:

”右边的部分，也就是说，

*一个INT，后面跟着一个PLUS，后面再接着一个INT。

至于INT和PLUS，它来自后面的定义：

PLUS :

'+';

INT  :

（'0'..'9'）+;

*PLUS定义的token，就是一个单一的“+”

*INT定义的token，由从'0'到'9'之间任意的数字组成，后面的加号表示它是可以重复一次到多次

如果你曾经与Antlr2.x有过一面之缘，你会发现，这个语法文件与Antlr2.x的语法文件有着些许不同。

首先，我们没有区分词法分析和语法分析，由上面的代码可以看出，二者在形式上是一致的，不同的是，对于词法分析的输入是字符，而语法分析的输入是词法分析的结果，也就是token。

Antlr2.x必须显式的区分这二者，而在Antlr3.0之后，Antlr会替你料理这一切。

再有，这里的语法文件名必须与grammar定义的名字保持一致，对于Java程序员，这是一个顺其自然的选择。

编译语法文件

如同不编译的程序是无法发挥其威力一样，单单语法文件对我们来说，并没有很大的价值。

我们的工作就是使用Antlr提供工具对我们的语法文件进行编译，不同于日常的编译器输出可执行文件，这里的输出是程序语言的源文件。

Antlr缺省目标语言是Java语言，它也可以支持C，C#和Python语言，其他的语言尚在开发之中，从3.0发布包结构来看，Ruby的支持很快就会加进来。

将Antlr提供的JAR文件加入到classpath中，其中包括Antlr2.7.7，Antlr3.0与其runtime，stringtemplate。

你没看错，除了3.0，这里还包含着2.7.7。

原因很简单，Antlr3.0是基于之前版本开发的。

然后把语法文件的名称作为参数传给语法编译器：

javaorg.antlr.ToolCaculator.g

在确保命令正确执行，且语法文件编写正确的情况下，Antlr为我们生成了几个文件：

*CalculatorLexer.java

*CalculatorParser.java

*Calculator__.g

*Calculator.tokens

正如前面说过的，Antlr替我们料理好了词法分析和语法分析，其中，CalculatorLexer.java就是我们的词法分析器，而CalculatorParser.java中包含了语法分析器，它们是我们这里关注的主要对象。

至于另外两个文件，Calculator__.g是一个自动生成的lexer语法文件，而Calculator.tokens则是列出了我们定义的token，我们并不会在程序中和它们直接打交道，所以，让我们暂时忽略它们的存在。

运行程序

生成代码之后，就是如何使用这些生成的代码。

下面就是我们的主程序，它负责将词法分析部分（Lexer）和语法分析部分（Parser）驱动起来：

publicclassMain{

   publicstaticvoidmain（String[]args）throwsException{

       ANTLRInputStreaminput=newANTLRInputStream（System.in）;

       CalculatorLexerlexer=newCalculatorLexer（input）;

       CommonTokenStreamtokens=newCommonTokenStream（lexer）;

       CalculatorParserparser=newCalculatorParser（tokens）;

       try{

           parser.expr（）;

       }catch（RecognitionExceptione）{

           System.err.println（e）;

       }

   }

}

从这段代码中可以清晰的看出，Lexer的输入是一个字符流，而Parser则需要Lexer的协助来完成工作，用Lexer构造出的Token流作为其输入。

一切就绪，我们让它跑起来，尝试输入一些内容，看它是否能够通过验证。

事实证明，我们的程序可以轻松识别“1+1”，而对于不合法的东西，它会产生一些抱怨。

计算结果

还记得我们的目标吗？

我们的目标是计算出“1+1”的结果，而现在这个程序刚刚能够识别出“1+1”，我们还要继续前进。

熟悉XML解析的朋友对于SAX和DOM一定不陌生，二者之间差别在于SAX属于边解析边处理，而DOM则是把所有的内容解析全部解析完（在内存中形成一棵树）之后，再统一处理。

Antlr也有与之类似的两种处理方式，SAX的朋友是在Parser中加入处理动作（Action）处理将随着解析的过程进行，而DOM的伙伴则是解析形成一棵抽象语法树（AbstractSyntaxTree，简称AST），再对树进行处理。

加入Action

先来看看SAX的朋友。

因为处理动作是加在expr上，其它部分保持不变。

下面是修改过的expr：

exprreturns[intvalue=0]

       :

a=INTPLUSb=INT

         {

             intaValue=Integer.parseInt（$a.text）;

             intbValue=Integer.parseInt（$b.text）;

             value=aValue+bValue;

         }

       ;

看到常用的字符串转整数的方法，熟悉Java的朋友想必已经露出了会心的微笑。

没错，这里定义Action的方法采用就是Java语言，因为我们生成的目标是Java，如果你期待另辟蹊径，那这里的代码就要用你的目标语言来编写。

仔细看一下不难发现，action完全是在原有的规则基础上改造的来。

首先用returns定义了这个Action的返回值，它将返回value这个变量的值，其类型是int，我们还顺便定义这个变量的初始值——“0”。

接下来，我们用a、b拿住了两个token的值，我们前面说过，在检查的过程中，我们并不关心每个token具体的