• getFirstChild: 返回第一个子结点的引用.
• getNextSibling: 返回下一个兄弟结点的引用.

/** 最小AST结点接口用于ANTLR的AST成生
*   和树遍历
*/
public interface AST {
/** 添加一个子结点到最右边 */
public void addChild(AST c);
public boolean equals(AST t);
public boolean equalsList(AST t);
public boolean equalsListPartial(AST t);
public boolean equalsTree(AST t);
public boolean equalsTreePartial(AST t);
public ASTEnumeration findAll(AST tree);
public ASTEnumeration findAllPartial(AST subtree);
/** 得到第一个子结点; 如果没有子结点则返回null */
public AST getFirstChild();
/** 得到本结点的下一个兄弟结点 */
public AST getNextSibling();
/** 得到本结点的记号文本 */
public String getText();
/** 得到本结点的记号类型 */
public int getType();
/** 得到本结点的子结点总数; 如果是叶子结点, 返回0 */
public int getNumberOfChildren();
public void initialize(int t, String txt);
public void initialize(AST t);
public void initialize(Token t);
/** 设置第一个子结点. */
public void setFirstChild(AST c);
/** 设置下一个兄弟结点. */
public void setNextSibling(AST n);
/** 设置本结点的记号文本 */
public void setText(String text);
/** 设置本结点的记号类型 */
public void setType(int ttype);
public String toString();
public String toStringList();
public String toStringTree();
}

树的语法规则

规则: 可选产生式1
|   可选产生式2
...
|   可选产生式n
;

#( 根结点 子结点1 子结点2 ... 子结点n )

#( PLUS INT INT )

#( IF expr stat (stat)? )    

句法断言

expr:   ( #(MINUS expr expr) )=> #( MINUS expr expr )
|   #( MINUS expr )
...
;

语义断言

一个树遍历器的例子

class CalcParser extends Parser;
options {
buildAST = true;   // // 默认使用 CommonAST
}
expr:   mexpr (PLUS^ mexpr)* SEMI!
;
mexpr
:   atom (STAR^ atom)*
;
atom:   INT
;

class CalcLexer extends Lexer;
WS  :   (' '
|   '\t'
|   '\n'
|   '\r')
{ _ttype = Token.SKIP; }
;
LPAREN: '('
;
RPAREN: ')'
;
STAR:   '*'
;
PLUS:   '+'
;
SEMI:   ';'
;
INT :   ('0'..'9')+
;    

class CalcTreeWalker extends TreeParser;
expr    :   #(PLUS expr expr)
|   #(STAR expr expr)
|   INT
;

class CalcTreeWalker extends TreeParser;
expr returns [int r]
{
int a,b;
r=0;
}
:   #(PLUS a=expr b=expr) {r = a+b;}
|   #(STAR a=expr b=expr) {r = a*b;}
|   i:INT             {r = Integer.parseInt(i.getText());}
;    

import java.io.*;
import antlr.CommonAST;
import antlr.collections.AST;
class Calc {
public static void main(String[] args) {
try {
CalcLexer lexer =
new CalcLexer(new DataInputStream(System.in));
CalcParser parser = new CalcParser(lexer);
// 分析输入的表达式
parser.expr();
CommonAST t = (CommonAST)parser.getAST();
// 以LISP符号的形式输出树
System.out.println(t.toStringList());
CalcTreeWalker walker = new CalcTreeWalker();
// 遍历由分析器建立的树
int r = walker.expr(t);
System.out.println("value is "+r);
} catch(Exception e) {
System.err.println("exception: "+e);
}
}
}    

翻译

一个树翻译的例子

class CalcTreeWalker extends TreeParser;
options{
buildAST = true;   // "翻译"模式
}
expr:!  #(PLUS left:expr right:expr)
// '!'关闭自动翻译
{
// x+0 = x
if ( #right.getType()==INT &&
Integer.parseInt(#right.getText())==0 )
{
#expr = #left;
}
// 0+x = x
else if ( #left.getType()==INT &&
Integer.parseInt(#left.getText())==0 )
{
#expr = #right;
}
// x+y
else {
#expr = #(PLUS, left, right);
}
}
|   #(STAR expr expr)  // 使用自动翻译
|   i:INT
;    

import java.io.*;
import antlr.CommonAST;
import antlr.collections.AST;
class Calc {
public static void main(String[] args) {
try {
CalcLexer lexer =
new CalcLexer(new DataInputStream(System.in));
CalcParser parser = new CalcParser(lexer);
// 分析输入的表达式
parser.expr();
CommonAST t = (CommonAST)parser.getAST();
// 以LISP符号的形式输出树
System.out.println(t.toLispString());
CalcTreeWalker walker = new CalcTreeWalker();
// 遍历由分析器建立的树
walker.expr(t);
// 遍历，并得到结果
t = (CommonAST)walker.getAST();
System.out.println(t.toLispString());
} catch(Exception e) {
System.err.println("exception: "+e);
}
}
}
}

检查/调试AST

public static void main(String args[]) {
// 创建树结点
ASTFactory factory = new ASTFactory();
CommonAST r = (CommonAST)factory.create(0, "ROOT");
r.addChild((CommonAST)factory.create(0, "C1"));
r.addChild((CommonAST)factory.create(0, "C2"));
r.addChild((CommonAST)factory.create(0, "C3"));
ASTFrame frame = new ASTFrame("AST JTree Example", r);
frame.setVisible(true);
}

分享

微博 QQ 微信

293篇文章，51W+人气，0粉丝