们使用ANTLR来描述了Jerry语言的基本语法,并通过ANTLRWorks来实验该语法对样本代码生成的解析树。但如同上一篇最后所述,这样得到的解析树中有太多对后续处理来说无用的冗余信息。我们需要消除这些冗余信息,得到抽象语法树(AST)。
本篇将以之前做的语法为基础,通过添加树重写规则来将ANTLR默认生成的解析树简化整理为抽象语法树。

本文涉及的源码和运行时库打包在附件里了,懒得复制粘贴的话就直接下载附件的版本,用ANTLRWorks来查看和编辑语法文件吧~

修改后的语法文件如下:
Jerry.g(ANTLR 3.1语法文件,以Java为生成目标语言)
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. grammar Jerry;  
  2.   
  3. options {  
  4.     language = Java;  
  5.     output = AST;  
  6.     ASTLabelType = CommonTree;  
  7. }  
  8.   
  9. tokens {  
  10.     // imaginary tokens  
  11.     VAR_DECL;  
  12.     SIMPLE_TYPE;  
  13.     ARRAY_TYPE;  
  14.     ARRAY_LITERAL;  
  15.     SIMPLE_VAR_ACCESS;  
  16.     ARRAY_VAR_ACCESS;  
  17.     UNARY_MINUS;  
  18.     BLOCK;  
  19.     EXPR_STMT;  
  20. }  
  21.   
  22. // parser rules  
  23.   
  24. program :   statementList EOF!  
  25.         {  
  26.             System.out.println(  
  27.                 null == $statementList.tree ?  
  28.                 "null" :  
  29.                 $statementList.tree.toStringTree());  
  30.         }  
  31.     ;  
  32.   
  33. statementList  
  34.     :   statement*  
  35.     ;  
  36.   
  37. statement  
  38.     :   expressionStatement  
  39.     |   variableDeclaration  
  40.     |   blockStatement  
  41.     |   ifStatement  
  42.     |   whileStatement  
  43.     |   breakStatement  
  44.     |   readStatement  
  45.     |   writeStatement  
  46.     ;  
  47.   
  48. expressionStatement  
  49.     :   expression SEMICOLON  
  50.             -> ^( EXPR_STMT expression )  
  51.     ;  
  52.   
  53. variableDeclaration  
  54.     :   typeSpecifier  
  55.             ( Identifier  
  56.                 (   -> ^( VAR_DECL ^( SIMPLE_TYPE typeSpecifier ) Identifier )  
  57.                 | ( LBRACK Integer RBRACK )+  
  58.                     -> ^( VAR_DECL ^( ARRAY_TYPE typeSpecifier Integer+ ) Identifier )  
  59.                 | EQ expression  
  60.                     -> ^( VAR_DECL ^( SIMPLE_TYPE typeSpecifier ) Identifier expression )  
  61.                 | ( LBRACK Integer RBRACK )+ EQ arrayLiteral  
  62.                     -> ^( VAR_DECL ^( ARRAY_TYPE typeSpecifier Integer+ ) Identifier arrayLiteral )  
  63.                 )  
  64.             )  
  65.             ( COMMA id=Identifier  
  66.                 (   -> $variableDeclaration ^( VAR_DECL ^( SIMPLE_TYPE typeSpecifier ) $id )  
  67.                 | ( LBRACK dim1+=Integer RBRACK )+  
  68.                     -> $variableDeclaration ^( VAR_DECL ^( ARRAY_TYPE typeSpecifier $dim1+ ) $id )  
  69.                 | EQ exp=expression  
  70.                     -> $variableDeclaration ^( VAR_DECL ^( SIMPLE_TYPE typeSpecifier ) $id $exp )  
  71.                 | ( LBRACK dim2+=Integer RBRACK )+ EQ al=arrayLiteral  
  72.                     -> $variableDeclaration ^( VAR_DECL ^( ARRAY_TYPE typeSpecifier $dim2+ ) $id $al )  
  73.                 )  
  74.                 { if (null != $dim1) $dim1.clear(); if (null != $dim2) $dim2.clear(); }  
  75.             )*  
  76.         SEMICOLON  
  77.     ;  
  78.   
  79. typeSpecifier  
  80.     :   INT | REAL  
  81.     ;  
  82.   
  83. arrayLiteral  
  84.     :   LBRACE  
  85.             arrayLiteralElement ( COMMA arrayLiteralElement )*  
  86.         RBRACE  
  87.             -> ^( ARRAY_LITERAL arrayLiteralElement+ )  
  88.     ;  
  89.   
  90. arrayLiteralElement  
  91.     :   expression  
  92.     |   arrayLiteral  
  93.     ;  
  94.   
  95. blockStatement  
  96.     :   LBRACE statementList RBRACE  
  97.             -> ^( BLOCK statementList )  
  98.     ;  
  99.   
  100. ifStatement  
  101.     :   IF^ LPAREN! expression RPAREN! statement ( ELSE! statement )?  
  102.     ;  
  103.   
  104. whileStatement  
  105.     :   WHILE^ LPAREN! expression RPAREN! statement  
  106.     ;  
  107.   
  108. breakStatement  
  109.     :   BREAK SEMICOLON!  
  110.     ;  
  111.   
  112. readStatement  
  113.     :   READ^ variableAccess SEMICOLON!  
  114.     ;  
  115.   
  116. writeStatement  
  117.     :   WRITE^ expression SEMICOLON!  
  118.     ;  
  119.   
  120. variableAccess  
  121.     :   Identifier  
  122.         (   -> ^( SIMPLE_VAR_ACCESS Identifier )  
  123.         | ( LBRACK Integer RBRACK )+  
  124.             -> ^( ARRAY_VAR_ACCESS Identifier Integer+ )  
  125.         )  
  126.     ;  
  127.   
  128. expression  
  129.     :   assignmentExpression  
  130.     |   logicalOrExpression  
  131.     ;  
  132.   
  133. assignmentExpression  
  134.     :   variableAccess EQ^ expression  
  135.     ;  
  136.   
  137. logicalOrExpression  
  138.     :   logicalAndExpression ( OROR^ logicalAndExpression )*  
  139.     ;  
  140.   
  141. logicalAndExpression  
  142.     :   relationalExpression ( ANDAND^ relationalExpression )*  
  143.     ;  
  144.   
  145. relationalExpression  
  146.     :   additiveExpression ( relationalOperator^ additiveExpression )?  
  147.     |   BANG^ relationalExpression  
  148.     ;  
  149.   
  150. additiveExpression  
  151.     :   multiplicativeExpression ( additiveOperator^ multiplicativeExpression )*  
  152.     ;  
  153.     
  154. multiplicativeExpression  
  155.     :   primaryExpression ( multiplicativeOperator^ primaryExpression )*  
  156.     ;  
  157.   
  158. primaryExpression  
  159.     :   variableAccess  
  160.     |   Integer  
  161.     |   RealNumber  
  162.     |   LPAREN! expression RPAREN!  
  163.     |   MINUS primaryExpression  
  164.             -> ^( UNARY_MINUS primaryExpression )  
  165.     ;  
  166.   
  167. relationalOperator     
  168.     :   LT | GT | EQEQ | LE | GE | NE  
  169.     ;  
  170.   
  171. additiveOperator  
  172.     :   PLUS | MINUS  
  173.     ;  
  174.   
  175. multiplicativeOperator  
  176.     :   MUL | DIV  
  177.     ;  
  178.   
  179. // lexer rules  
  180.   
  181. LPAREN  :   '('  
  182.     ;  
  183.   
  184. RPAREN  :   ')'  
  185.     ;  
  186.   
  187. LBRACK  :   '['  
  188.     ;  
  189.   
  190. RBRACK  :   ']'  
  191.     ;  
  192.   
  193. LBRACE  :   '{'  
  194.     ;  
  195.   
  196. RBRACE  :   '}'  
  197.     ;  
  198.   
  199. COMMA   :   ','  
  200.     ;  
  201.   
  202. SEMICOLON  
  203.     :   ';'  
  204.     ;  
  205.   
  206. PLUS    :   '+'  
  207.     ;  
  208.   
  209. MINUS   :   '-'  
  210.     ;  
  211.   
  212. MUL :   '*'  
  213.     ;  
  214.   
  215. DIV :   '/'  
  216.     ;  
  217.   
  218. EQEQ    :   '=='  
  219.     ;  
  220.   
  221. NE  :   '!='  
  222.     ;  
  223.   
  224. LT  :   '<'  
  225.     ;  
  226.   
  227. LE  :   '<='  
  228.     ;  
  229.   
  230. GT  :   '>'  
  231.     ;  
  232.   
  233. GE  :   '>='  
  234.     ;  
  235.   
  236. BANG    :   '!'  
  237.     ;  
  238.   
  239. ANDAND  :   '&&'  
  240.     ;  
  241.   
  242. OROR    :   '||'  
  243.     ;  
  244.   
  245. EQ  :   '='  
  246.     ;  
  247.   
  248. IF  :   'if'  
  249.     ;  
  250.   
  251. ELSE    :   'else'  
  252.     ;  
  253.   
  254. WHILE   :   'while'  
  255.     ;  
  256.   
  257. BREAK   :   'break'  
  258.     ;  
  259.   
  260. READ    :   'read'  
  261.     ;  
  262.   
  263. WRITE   :   'write'  
  264.     ;  
  265.   
  266. INT :   'int'  
  267.     ;  
  268.   
  269. REAL    :   'real'  
  270.     ;  
  271.   
  272. Identifier  
  273.     :   LetterOrUnderscore ( LetterOrUnderscore | Digit )*  
  274.     ;  
  275.   
  276. Integer :   Digit+  
  277.     ;  
  278.   
  279. RealNumber  
  280.     :   Digit+ '.' Digit+  
  281.     ;  
  282.   
  283. fragment  
  284. Digit   :   '0'..'9'  
  285.     ;  
  286.   
  287. fragment  
  288. LetterOrUnderscore  
  289.     :   Letter | '_'  
  290.     ;  
  291.   
  292. fragment  
  293. Letter  :   ( 'a'..'z' | 'A'..'Z' )  
  294.     ;  
  295.   
  296. WS  :   ( ' ' | '\t' | '\r' | '\n' )+ { $channel = HIDDEN; }     
  297.     ;  
  298.   
  299. Comment  
  300.     :   '/*' ( options { greedy = false; } : . )* '*/' { $channel = HIDDEN; }  
  301.     ;  
  302.   
  303. LineComment  
  304.     :   '//' ~('\n'|'\r')* '\r'? '\n' { $channel = HIDDEN; }  
  305.     ;  


稍微说明一下修改点。应该观察到lexer rules部分是完全没有改变的,修改的主要是一些选项和parser rules。

首先,在文件的开头添加了一组选项:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. options {  
  2.     language = Java;  
  3.     output = AST;  
  4.     ASTLabelType = CommonTree;  
  5. }  

ANTLR会知道应该使用生成AST的模式,以CommonTree作为AST的节点类型,并以Java作为生成的解析器源码的语言。上一篇是在 ANTLRWorks里编辑和实验语法的,这次我们需要生成实际能运行的解析器,所以需要指定这些选项(默认就是生成Java源码,不过后续文章中我应该 会换用CSharp2目标。这个以后再说)。

接下来,可以看到除了原本在lexer rules里定义的实际存在的token类型之外,这次我们在语法文件的开头还增加了一组虚拟的token类型。这些token类型是为了让生成出来的抽象语法树易于解析而添加的。
例如,观察VAR_DECL这个token类型。在原本的语法中,没有任何关键字能清楚的标识出当前处理的内容是一个变量声明。为了方便后续分析,我们可以“制造”出一个虚构的token作为一个变量声明语句的根元素,然后以变量的类型、标识符和初始值为子元素。

然后就是最重要的部分,树重写规则了。有两种形式来表述树重写规则:一是直接在原本的语法规则上添加树生成用的运算符(^和!),二是在原本的语法规则后添加一个箭头("->"),并在箭头后显式指定需要生成的节点的结构。
看两个例子:
while语句。原本的语法是:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. whileStatement : 'while' '(' expression ')' statement ;  

这里我们想让生成出来的子树以'while'为根节点,以expression和statement为子节点。
可以直接在该语法上添加树生成运算符:在某个元素后加上帽子符号('^')来表示它是生成的子树的根节点,在某个元素后加上叹号('!')来表示生成的子树中应该忽略该元素。于是修改得到的语法是:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. whileStatement : 'while'^ '('! expression ')'! statement ;  

也可以显式指定树重写规则。一棵子树用这种方式来表示:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. ^( root element1 element2 ... )  

这里我们要的就是:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. whileStatement : 'while' '(' expression ')' statement  
  2.     -> ^( 'while' expression statement )  
  3.   ;  

这种形式我们能一目了然看到最终生成的子树的结构。
两种形式是等价的,可以根据具体情况来选择能简单而清晰的表示出树改写规则的版本。

对表达式相关的语法规则,我们几乎都是用添加运算符的形式来表示树改写规则,因为对左结合的双目运算符,这样是最简洁的。
ANTLR生成的解析器使用LL(*)算法;与一般的LL解析器一样,ANTLR不支持左递归的语法规则。这使得书写左结合的双目运算符时,一般得写成这样的形式:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. exprWithHigherPrecedence  
  2.   : exprWithLowerPrecedence ( op exprWithLowerPrecedence )*  
  3.   ;  

而不能以左递归来指定左结合。(但右结合还是可以用右递归来指定的。)
那么在表示树改写规则的时候,使用运算符来修饰语法就是这样:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. exprWithHigherPrecedence  
  2.   : exprWithLowerPrecedence ( op^ exprWithLowerPrecedence )*  
  3.   ;  

只是在op的后面添加了一个帽子符号('^'),表明在没有匹配到op运算符时就直接返回exprWithLowerPrecedence规则所 生成的树;而如果匹配到了op运算符,则每匹配到一次就生成一个新的以op为根节点的、前后两个较低优先级的表达式节点为子节点的树。
这个树改写规则如果要显式指定,就得写成:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. exprWithHigherPrecedence  
  2.   : exprWithLowerPrecedence  
  3.       ( op exp=exprWithLowerPrecedence  
  4.           -> ^( op $exprWithHigherPrecedence $exp )  
  5.       )*  
  6.   ;  

后者相比之下麻烦多了,所以一般都会使用前者。

可惜C风格的变量声明语句的语法很麻烦,结果variableDeclaration在修改后膨胀了好多 T T
最不爽的地方就是C风格的数组变量声明是把数组的维度写在变量名后面的。这就使得语句开头的类型(例如int、char等)可能只是变量的实际类型的一部分,而另一部分要在变量名的之前(例如表示指针的星号('*'))或之后(例如表示数组的方括号('[' ']'))。
就不能把整个类型写在一起么……T T 于是衍生出来的Java和C#明显都吸取了这个教训。

在语法的program规则中,我们添加了一条嵌入语法动作,让生成的解析器在匹配完program规则后将其对应的抽象语法树以字符串的形式输出出来。

如果是在ANTLRWorks里编辑该语法文件,可以在菜单里选择Generate -> Generate Code来生成出解析器的源码。这里例子中我们会得到JerryLexer.java和JerryParser.java。
要运行这个解析器,还需要写一个简单的启动程序来调用生成出来的JerryLexer和JerryParser。源码如下:
TestJerry.java
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. import org.antlr.runtime.*;  
  2.   
  3. public class TestJerry {  
  4.     public static void main(String[] args) throws Exception {  
  5.         // Create an input character stream from standard in  
  6.         ANTLRInputStream input = new ANTLRInputStream(System.in);  
  7.         // Create an JerryLexer that feeds from that stream  
  8.         JerryLexer lexer = new JerryLexer(input);  
  9.         // Create a stream of tokens fed by the lexer  
  10.         CommonTokenStream tokens = new CommonTokenStream(lexer);  
  11.         // Create a parser that feeds off the token stream  
  12.         JerryParser parser = new JerryParser(tokens);  
  13.         // Begin parsing at rule prog  
  14.         parser.program();  
  15.     }  
  16. }  

它指定从标准输入流得到要解析的Jerry代码,然后通过JerryLexer将代码解析成token流,再将token流交给JerryParser进行句法分析。

将JerryLexer.java、JerryParser.java和TestJerry.java放在跟ANTLRWorks同一目录下,然后编译它们:
引用
javac -Xlint:unchecked -cp antlrworks-1.2.2.jar JerryLexer.java JerryParser.java TestJerry.java

(因为ANTLRWorks里含有ANTLR的运行时库,而我正好又是用ANTLRWorks来编辑语法文件的,所以直接用ANTLRWorks 的JAR包放在classpath里来得到需要的ANTLR运行时类。实际开发的话可以从ANTLR官网获得只含有ANTLR运行时库的JAR包并在编译 和运行的时候将其添加到classpath里。)

上一篇的最后有这样的一段Jerry例子:
C代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. // line comment  
  2. // declare variables with/without initializers  
  3. int i = 1, j;  
  4. int x = i + 2 * 3 - 4 / ( 6 - - 7 );  
  5. int array[2][3] = {  
  6.   { 0, 1, 2 },  
  7.   { 3, 4, 6 }  
  8. };  
  9.   
  10. /* 
  11.   block comment 
  12. */  
  13.   
  14. while (i < 10) i = i + 1;  
  15. while (!x > 0 && i < 10) {  
  16.   x = x - 1;  
  17.   if (i < 5) break;  
  18.   else read i;  
  19. }  
  20.   
  21. write x - j;  

(语法是符合要求的,至于代码的意义就别追究了,只是用来演示各种语法结构随便写的)

用本篇的ANTLR语法文件生成的解析器,我们可以解析这个例子,得到对应的抽象语法树的字符串表示。表示方法是:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. (root element1 element2 ...)  

跟LISP的S-expression非常类似。

于是执行测试程序。将要解析的代码保存到JerrySample.txt中,然后执行下面的命令:
引用
java -cp ".;antlrworks-1.2.2.jar" TestJerry < JerrySample.txt

得到输出:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. (VAR_DECL (SIMPLE_TYPE int) i 1) (VAR_DECL (SIMPLE_TYPE int) j) (VAR_DECL (SIMPLE_TYPE int) x (- (+ (SIMPLE_VAR_ACCESS i) (* 2 3)) (/ 4 (- 6 (UNARY_MINUS 7))))) (VAR_DECL (ARRAY_TYPE int 2 3) array (ARRAY_LITERAL (ARRAY_LITERAL 0 1 2) (ARRAY_LITERAL 3 4 6))) (while (< (SIMPLE_VAR_ACCESS i) 10) (= (SIMPLE_VAR_ACCESS i) (+ (SIMPLE_VAR_ACCESS i) 1))) (while (&& (! (> (SIMPLE_VAR_ACCESS x) 0)) (< (SIMPLE_VAR_ACCESS i) 10)) (BLOCK (= (SIMPLE_VAR_ACCESS x) (- (SIMPLE_VAR_ACCESS x) 1)) (if (< (SIMPLE_VAR_ACCESS i) 5) break (read (SIMPLE_VAR_ACCESS i))))) (write (- (SIMPLE_VAR_ACCESS x) (SIMPLE_VAR_ACCESS j)))  

这样太乱了看不清楚。将其格式稍微整理一下得到:
Java代码  一个简单的语言的语法(二):ANTLR的重写规则_运算符
  1. (VAR_DECL  
  2.   (SIMPLE_TYPE int)  
  3.   i  
  4.   1  
  5. )  
  6. (VAR_DECL  
  7.   (SIMPLE_TYPE int)  
  8.   j  
  9. )  
  10. (VAR_DECL  
  11.   (SIMPLE_TYPE int)  
  12.   x  
  13.   (-  
  14.     (+ (SIMPLE_VAR_ACCESS i) (* 2 3))  
  15.     (/ 4 (- 6 (UNARY_MINUS 7)))  
  16.   )  
  17. )  
  18. (VAR_DECL  
  19.   (ARRAY_TYPE  
  20.     int  
  21.     2  
  22.     3  
  23.   )  
  24.   array  
  25.   (ARRAY_LITERAL  
  26.     (ARRAY_LITERAL 0 1 2)  
  27.     (ARRAY_LITERAL 3 4 6)  
  28.   )  
  29. )  
  30.   
  31. (while  
  32.   (< (SIMPLE_VAR_ACCESS i) 10)  
  33.   (= (SIMPLE_VAR_ACCESS i) (+ (SIMPLE_VAR_ACCESS i) 1))  
  34. )  
  35. (while  
  36.   (&&  
  37.     (! (> (SIMPLE_VAR_ACCESS x) 0))  
  38.     (< (SIMPLE_VAR_ACCESS i) 10)  
  39.   )  
  40.   (BLOCK  
  41.     (= (SIMPLE_VAR_ACCESS x) (- (SIMPLE_VAR_ACCESS x) 1))  
  42.     (if  
  43.       (< (SIMPLE_VAR_ACCESS i) 5)  
  44.       break  
  45.       (read (SIMPLE_VAR_ACCESS i))  
  46.     )  
  47.   )  
  48. )  
  49. (write  
  50.   (- (SIMPLE_VAR_ACCESS x) (SIMPLE_VAR_ACCESS j)))  

可以跟原本的代码对比一下,看看是否保持了原本的结构。

得到这棵抽象语法树之后,接下来就可以对树来做匹配和分析了。由于树本身已经有了结构,下面就可以用更干净的描述方式来表述我们要对树做的处理。