ANTLR一个编译简单的两数相加的例子

如同程序设计语言入门大多采用“Hello World”一样，编译领域的入门往往选择计算器。一个只能计算两个数相加的计算器，也就是说，它可以计算“1+1”

编译过程分两步走：

1 先要能识别1+1这样的格式<o:p></o:p>

检查输入的正确性，只有对正确的输入进行计算才是有意义的。如同写文章有形式和内容之分，这里的检查也要细分一下，这个过程叫做词法分析。在我们的计算器中，我们只接受整数和加号，其它的一概不理。这里我们说的是“整数”，而非 “1”、“2”……，对我们来说，它们代表着同一类的东西，编译原理称为叫做token

编写语法文件<o:p></o:p>

制订好自己的语言规则之后，我们需要以Antlr的语言把它描述出来。
下面便是以Antlr的语言描述的语法：
class CaculatorParser extends Parser;
expr:   INT PLUS INT; <o:p></o:p>

class CaculatorLexer extends Lexer;
PLUS  : '+' ;
INT   : ('0'..'9')+ ;<o:p></o:p>

Antlr的语法文件通常会保存在一个“.g”的文件中，我们的语法文件叫做“caculator.g”。<o:p></o:p>

先来看看Lexer部分，它便是我们前面所说的词法分析器。首先声明自己的Lexer：
class CaculatorLexer extends Lexer;
这句话有两个作用，其一，为生成代码中的词法分析器定义名字，其二，告诉Antlr，我要定义词法规则了。既然说到词法规则，紧接着我们就定义了两条词法规则：
PLUS  : '+' ;
INT   : ('0'..'9')+ ;
这里的规则很容易看懂：
* PLUS定义的token，就是一个单一的“+”
* INT定义的token，由从'0'到'9'之间任意的数字组成，后面的加号表示它是可以重复一次到多次<o:p></o:p>

定义好Lexer之后，便轮到Parser了：
class CaculatorParser extends Parser;
它的作用同Lexer的定义一样，之后是语法规则：
expr:   INT PLUS INT;

<o:p> </o:p>

编译语法文件<o:p></o:p>

使用Antlr提供工具对我们的语法文件进行编译，不同 于日常的编译器输出可执行文件，这里的输出是程序语言的源文件。Antlr缺省目标语言是Java语言，它也可以支持C++和C#语言。<o:p></o:p>

将antlr.jar加到classpath中，然后把语法文件的名称作为参数传给语法编译器：
java antlr.Tool caculator.g<o:p></o:p>

在确保命令正确执行，且语法文件编写正确的情况下，Antlr为我们生成了几个文件：
CaculatorLexer.java
CaculatorLexerTokenTypes.java
CaculatorLexerTokenTypes.txt
CaculatorParser.java
CaculatorParserTokenTypes.java
CaculatorParserTokenTypes.txt<o:p></o:p>

这里主要关心的是CaculatorLexer.java和CaculatorParser.java，它们就是我们在语法文件中定义的Lexer和Parser。其它几个文件只是定义了一些常量，让我们暂时忽略它们的存在。<o:p></o:p>

运行程序
生成代码之后，就是如何使用这些生成的代码。下面就是我们的主程序，它负责将Lexer和Parser驱动起来：
public class Main {
    public static void main(String[] args) throws Exception {
        CaculatorLexer lexer = new CaculatorLexer(System.in);
        CaculatorParser parser = new CaculatorParser(lexer);
        try {
            parser.expr();
        } catch (Exception e) {
            System.err.println(e);
        }
    }
}
从这段代码中可以清晰的看出，Lexer的输入是一个字符流，而Parser则需要Lexer的协助来完成工作。我们可以输入一些内容，看它是否能够通过验证。事实证明，我们的程序可以轻松识别“1+1”，而对于不合法的东西，它会产生一些异常。

2 可以对其编译进行计算。<o:p></o:p>

目标是计算出“1+1”的结果，而现在这个程序刚刚能够识别出“1+1”，还需要步骤。可以有两种方法来解析，分部是SAX和DOM方式：

SAX属于边解析边处理，而DOM则是把所有的内容解析全部解析完（在内存中形成语法树）之后，再统一处理。Antlr的SAX方式是在Parser中加入处理动作（Action）处理将随着解析的过程进行， 而DOM的伙伴则是解析形成一棵抽象语法树（Abstract Syntax Tree，AST），再对树进行处理。<o:p></o:p>

SAX方式：<o:p></o:p>

加入Action<o:p></o:p>

因为处理动作是加在Parser中的，所以，我们的Lexer保持不变，下面是修改过的Parser。
class CaculatorParser extends Parser;
expr returns [int value=0]
      :  a : INT PLUS b : INT {
          int aValue = Integer.parseInt(a.getText());
          int bValue = Integer.parseInt(b.getText());
          value = aValue + bValue;
      };
这里有常用的字符串转整数的方法，这里定义Action的方法采用就是Java语言，因为我们生成的目标是Java，那这里的代码就要你需要的目标语言来编写。<o:p></o:p>

action完全是在原有的规则基础上改造的来。首先用returns定义了这个Action的返回值，它将返回value这个变量的值，其类型是int，我们还顺便定义这个变量的初始值——“<st1:chmetcnv unitname="”" sourcevalue="0" hasspace="False" negative="False" numbertype="1" tcsc="0" w:st="on">0”</st1:chmetcnv>。接下来，用a、b拿住了两个token的值，我们前面说过，在检查的过程中，我们并 不关心每个token具体的内容，只要token的类型满足需要即可，但在action中，我们要计算结果，那必须使用token具体的内容，所以，我们 用变量拿住了token。在生成的代码中，a的类型antlr.Token，因此，我们通过a.getText()来获得token的具体值。剩下的动作 就很简单了，把文本转换为数字，进行加法运算。<o:p></o:p>

然后生成全新的Parser。稍微修改一下主程序，就可以对1+1进行编译计算了
public class Main {
    public static void main(String[] args) throws Exception {
        CaculatorLexer lexer = new CaculatorLexer(System.in);
        CaculatorParser parser = new CaculatorParser(lexer);
        try {
            System.out.println(parser.expr());
        } catch (Exception e) {
            System.err.println(e);
        }
    }
}
在输入的时候 输入1+1 就可以得到结果了。

<o:p> </o:p>

DOM方式
使用DOM方式，首先需建立一个AST语法树：
建立AST的方式很简单，只要我们Antlr一个建立AST的选项即可，下面就是新的Parser：
class CaculatorParser extends Parser;<o:p></o:p>

options {
    buildAST=true;
}<o:p></o:p>

expr:   INT PLUS^ INT;<o:p></o:p>

稍微有些不同的地方在PLUS上面的“^”，这个符号用来告诉Antlr创建一个节点，以此作为当前树的根节点。<o:p></o:p>

下面将DOM方式的重点部分TreeParser：
class CaculatorTreeParser extends TreeParser;<o:p></o:p>

expr returns [int value = 0;]  //定义规则
      : #(PLUS a : INT b : INT) {
          int aValue = Integer.parseInt(a.getText());
          int bValue = Integer.parseInt(b.getText());
          value = aValue + bValue;
      };
Antlr 可以接受三种类型语法规范——Lexer、Parser和Tree-Parser。如果说Lexer处理的是字符流、Parser处理的是Token流， 那么TreeParser处理的则是AST。前面Action的处理方式中，我们看到，规则同处理放到了一起，显得有些混乱，而采用了AST的处理方式， 规则同处理就完全分离了：在Parser中定义规则，在TreeParser中定义处理，如果我们需要对同样的语法进行另外的处理，我们只要重新 TreeParser，从而降低耦合度，Hibernate采用的就是这种方式！！<o:p></o:p>

可以参考前面ACTION，来看TreeParser如何编写也就简单许多，需要说明的就是：
#(PLUS a : INT b : INT)
除去变量的说明，简化一下这段代码
#(PLUS INT INT)
第一个符号PLUS对应了表示着根节点，两个INT则分别代表了两棵子树。<o:p></o:p>

再来看看重新打造的主程序
public class Main {
    public static void main(String[] args) {
        CaculatorLexer lexer = new CaculatorLexer(System.in);
        CaculatorParser parser = new CaculatorParser(lexer);
        try {
            parser.expr();
            AST t = parser.getAST();
            CaculatorTreeParser treeParser = new CaculatorTreeParser();
            System.out.println(treeParser.expr(t));
        } catch (Exception e) {
            System.err.println(e);
        }
    }
}<o:p></o:p>

在输入的时候 输入1+1 就可以得到结果了。

<o:p> </o:p>

由此再参考Hibernate的处理方式，会发现很容易理解：<o:p></o:p>

Session s = factory.openSession();<o:p></o:p>

List auctions = s.createQuery("…");<o:p></o:p>

createQuery()的调用过程<o:p></o:p>

通过QueryPlanCache的getHQLQueryPlan()方法获得查询计划HQLQueryPlan的一个实例，而后者主要是调用了 QueryTranslator的compile方法，编译HQL语句。在QueryTranslator的继承类 QueryTranslatorImpl的doCompile观察这个过程：<o:p></o:p>

PHASE 1 : Parse the HQL into an AST.<o:p></o:p>

PHASE 2 : Analyze the HQL AST, and produce an SQL AST.<o:p></o:p>

PHASE 3 : Generate the SQL.<o:p></o:p>