构造一个语言识别器（翻译）

构造一个语言识别器

 

ANTLR: ANother Tool for Language Recognition (http://www.antlr.org)

 

原文出处：http://www.jguru.com/faq/view.jsp?EID=78

 

中英文单词对照：

grammar: 文法

syntax: 语法

action: 动作

lexer: 记号识别器

parser: 分析器

token: 记号

AST: 抽象语法树

lexer grammar: 记号识别器文法

parser grammar: 分析器文法

tree grammar: 分析树文法

tree parser: 分析树分析器

walk: 遍历

 

 

为了构造一个语言识别器，可以用文法（grammar）来说明那种语言的结构，然后用ANTLR来生成一个Java或C++写成的可以用来识别该语言中的语句的定义识别程序。可以加入一些简单的操作符来让ANTLR自动构造中间形式的语法树，稍后可以用于执行某种转换。也可以在文法中嵌入Java或C++的动作（actions）以收集信息或是执行某种转换。

进行简单的转换时，你将构造两个文法：一个lexer文法和一个parser文法，ANTLR可以根据它们生成一个lexer（通常被称作scanner或tokenizer）和一个parser。lexer将输入的字符流变成记号（tokens）流，而parser将在记号流上应用文法结构（语法）（grammatical structure (syntax)）。这里有个简单的lexer可以用来匹配逗号（commas）、整数（integers）和标识（identifiers）：

 

class IntAndIDLexer extends Lexer;

   

INT : ('0'..'9')+ ;

 

ID  : ('a'..'z')+ ;

 

COMMA: ',' ;

 

    通过反复地向lexer请求一个记号（token），parser将会看到一个记号流（a stream of tokens）。不仅如此，parser还会验证这个记号流是否有正确的句法结构。如果你的文法结构的定义是“一个由整数和标识组成，并且由逗号分隔的系列”，那么你可能需要一个看起来象这样的文法：

 

class SeriesParser extends Parser;

 

/** Match an element (INT or ID) with possibly a

 *  bunch of ", element" pairs to follow matching

 *  input that looks like 32,a,size,28923,i

 */

series : element (COMMA element)* ;

 

/** Match either an INT or ID */

element: INT | ID ;

 

你可能会想要在文法里嵌入动作（actions），这样，当parser看到了特定的输入结构时，这些代码片就会被执行。如果你想要打印一共发现了多少个元素，你可以象下面这样添加动作：

 

class SeriesParser extends Parser;

 

// I'm using Java...

 

/** Match an element (INT or ID) with possibly a

 *  bunch of ", element" pairs to follow matching

 *  input that looks like 32,a,size,28923,i

 */

series

{ /* this is considered an initialization action

   * and is done before recognition of this rule

   * begins.  These look like local variables to

   * the resulting method SeriesParser.series()

   */

  int n = 1; // how many elements?  At least 1

}

    :  element (COMMA element {n++;})*

       {System.out.println("there were "+n+" elements");}

    ;

 

/** Match either an INT or ID */

element: INT | ID ;

 

那么ANTLR到底对这些文法做了什么呢？好的，看看SeriesParser，ANTLR将会生成下列代码（除了错误处理部分）：

 

public class T extends antlr.LLkParser implements TTokenTypes {

 

// I cut out the usual set of constructors and a few

// other details.

 

/** Match an element (INT or ID) with possibly a

 *  bunch of ", element" pairs to follow matching

 *  input that looks like 32,a,size,28923,i

 */

public final void series() {

  element(); // match an element

  _loop3:

  do {

    if ((LA(1)==COMMA)) {

      match(COMMA);

      element();

    }

    else {

      break _loop3;

    }

  } while (true);

}

 

/** Match either an INT or ID */

public final void element() {

  switch ( LA(1)) {

  case INT:

  {

    match(INT);

    break;

  }

  case ID:

  {

    match(ID);

    break;

  }

  }

}

}

 

考虑一下上面的代码，你就会开始发现文法和上面的代码间的一一对应关系，跟手写的代码很相似。

为了使用lexer和parser，你需要一个main()方法来创建它们的实例，把它们联系起来并且调用parser里的规则：

 

main(String[] args) {

  DataInputStream input = new DataInputStream(System.in);

 

  // attach lexer to the input stream

  IntAndIDexer lexer = new IntAndIDexer(input);

 

  // Create parser attached to lexer

  SeriesParser parser = new SeriesParser(lexer);

 

  // start up the parser by calling the rule

  // at which you want to begin parsing.

  parser.series();

}

 

为了打印parser匹配到的记号的文本值，必须对相应项目进行标示。这个标示将会指向由lexer构造的Token对象。在一个动作里，可以获得记号对象的文本值：

 

class SeriesParser extends Parser;

 

series : element (COMMA element)* ;

 

element

    :    a:INT  {System.out.println(a.getText());}

    |    b:ID   {System.out.println(b.getText());}

    ;

输入 32,a,size,28923,i, 将会得到以下输出:

32

a

size

28923

i

 

更加复杂的转换一般需要对输入进行多次遍历，所以程序员一般会构造一棵叫抽象语法树（AST）的中间形式语法树，它是输入文本的机构化表现。你可以用手写代码来遍历语法树，也可以用ANTLR语法树文法来描述语法树的结构。嵌入在语法树文法中的动作将会在tree parser解析到输入语法树的相关位置时被执行。

怎样才能构造一棵简单语法树呢？很简单！告诉ANTLR去构造语法树它就会这么做，每个输入记号占一个节点；也就是说，ANTLR会构造一个由输入记号组成的链表。为了让事情更有趣，在COMMA记号后面加上一个‘！’来指出逗号并不需要被包括在输入语法树中：

 

class SeriesParser extends Parser;

options {

  buildAST = true;

}

 

series : element (COMMA! element)* ;

 

element: INT | ID ;

 

我们可以对AST做些什么操作呢？你可能会构造一个ANTLR的common AST的子类并且加入一个walk()方法或别的什么，不过更好的办法是用另一个文法来描述AST的结构。语法树文法（tree grammar）就像是可执行的对你的中间形式进行描述的注释。这里有一个很小的文法，它可以匹配由我们的parser grammar生成的语法树：

 

class SeriesTreeParser extends TreeParser;

 

/** Match a flat tree (a list) of one or more INTs or IDs.

 *  This rule differs from SeriesParser.series(), which

 *  is in a different grammar.

 */

series : ( INT | ID )+ ;

 

注意！语法树文法（tree grammar）要比分析器文法（parser grammer）简单。一般来说，你会构造相对简单的语法树以便于遍历，而不是面对包含了所有空白和其它语法修饰的输入文本，对人类而言，前者更容易接受。为了调用你的tree parser，需要增大main()方法：

 

main(String[] args) {

  DataInputStream input = new DataInputStream(System.in);

 

  // attach lexer to the input stream

  IntAndIDexer lexer = new IntAndIDexer(input);

 

  // Create parser attached to lexer

  SeriesParser parser = new SeriesParser(lexer);

 

  // start up the parser by calling the rule

  // at which you want to begin parsing.

  parser.series();

 

  // Get the tree out of the parser

  AST resultTree = parser.getAST();

 

  // Make an instance of the tree parser

  SeriesTreeParser treeParser = new SeriesTreeParser();

 

  // Begin tree parser at only rule

  treeParser.series(resultTree);

}

 

你可以往tree grammar里加入动作，就像往parser grammar里加动作一样简单。为了象在parser grammar里那样打印整数和标识的列表，需要加入几个动作：

 

class SeriesTreeParser extends TreeParser;

 

series

    :  (  a:INT  {System.out.println(a.getText());}

       |  b:ID   {System.out.println(b.getText());}

       )+

    ;

 

如果你还想再遍历AST一遍，用别的动作吗？一个办法是定义另一个一样的规则，但是对应不同的动作：

 

class SeriesTreeParser extends TreeParser;

 

series

    :  (  a:INT  {System.out.println(a.getText());}

       |  b:ID   {System.out.println(b.getText());}

       )+

    ;

 

/** Sum up all the integers for fun. */

passTwo

{

  int sum = 0;

}

    :  (  a:INT  {sum += Integer.parseInt(a.getText());}

       |  ID

       )+

       {System.out.println("sum is "+sum);}

    ;

于是，你的main()方法需要在调用series规则后调用这个新规则：

main(String[] args) {

  ...

  // Get the tree out of the parser

  AST resultTree = parser.getAST();

 

  // Make an instance of the tree parser

  SeriesTreeParser treeParser = new SeriesTreeParser();

 

  treeParser.series(resultTree);  // walk AST once

  treeParser.passTwo(resultTree); // walk AST again!!

}

 

你将会看到下面的输出：

32

a

size

28923

i

sum is 28955