如果您不希望评估某些子树,则需要让树规则返回节点而不是实际值.您可以扩展CommonTree并提供自定义TreeAdaptor来帮助构建自己的节点,但就个人而言,我发现最简单的方法是创建自定义节点类(或类)并使用它们.一个演示澄清：

T.G

grammar T;

options {

output=AST;

}

tokens {

ASSIGNMENT;

}

parse

: statement+ EOF -> statement+

;

statement

: ifStatement

| assignment

;

ifStatement

: IF a=expression THEN b=expression (ELSE c=expression)? -> ^(IF $a $b $c?)

;

assignment

: ID '=' expression -> ^(ASSIGNMENT ID expression)

;

expression

: orExpression

;

orExpression

: andExpression (OR^ andExpression)*

;

andExpression

: equalityExpression (AND^ equalityExpression)*

;

equalityExpression

: relationalExpression (('==' | '!=')^ relationalExpression)*

;

relationalExpression

: atom (('<=' | '=' | '>')^ atom)*

;

atom

: BOOLEAN

| NUMBER

| ID

| '(' expression ')' -> expression

;

IF : 'if';

THEN : 'then';

ELSE : 'else';

OR : 'or';

AND : 'and';

BOOLEAN : 'true' | 'false';

ID : ('a'..'z' | 'A'..'Z')+;

NUMBER : '0'..'9'+ ('.' '0'..'9'+)?;

SPACE : (' ' | '\t' | '\r' | '\n') {skip();};

Main.java

我创建了一个具有eval()：Object方法的Node接口,还创建了一个实现Node的抽象类BinaryNode,并且总是有2个子节点.正如您在这些Java类之后的树语法中所看到的,所有规则现在都返回一个Node.

import org.antlr.runtime.*;

import org.antlr.runtime.tree.*;

public class Main {

public static void main(String[] args) throws Exception {

String source = "a = 3 b = 4 if b > a then b==b else c==c";

TLexer lexer = new TLexer(new ANTLRStringStream(source));

TParser parser = new TParser(new CommonTokenStream(lexer));

TWalker walker = new TWalker(new CommonTreeNodeStream(parser.parse().getTree()));

Node root = walker.walk();

System.out.println(root.eval());

}

}

interface Node {

Object eval();

}

abstract class BinaryNode implements Node {

protected Node left;

protected Node right;

public BinaryNode(Node l, Node r) {

left = l;

right = r;

}

}

class AtomNode implements Node {

private Object value;

public AtomNode(Object v) {

value = v;

}

@Override

public Object eval() {

return value;

}

}

class OrNode extends BinaryNode {

public OrNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Boolean)super.left.eval() || (Boolean)super.right.eval();

}

}

class AndNode extends BinaryNode {

public AndNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Boolean)super.left.eval() && (Boolean)super.right.eval();

}

}

class LTNode extends BinaryNode {

public LTNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Double)super.left.eval() < (Double)super.right.eval();

}

}

class LTEqNode extends BinaryNode {

public LTEqNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Double)super.left.eval() <= (Double)super.right.eval();

}

}

class GTNode extends BinaryNode {

public GTNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Double)super.left.eval() > (Double)super.right.eval();

}

}

class GTEqNode extends BinaryNode {

public GTEqNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return (Double)super.left.eval() >= (Double)super.right.eval();

}

}

class EqNode extends BinaryNode {

public EqNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return super.left.eval().equals(super.right.eval());

}

}

class NEqNode extends BinaryNode {

public NEqNode(Node left, Node right) { super(left, right); }

@Override

public Object eval() {

return !super.left.eval().equals(super.right.eval());

}

}

class VarNode implements Node {

private java.util.Map memory;

private String var;

VarNode(java.util.Map m, String v) {

memory = m;

var = v;

}

@Override

public Object eval() {

Object value = memory.get(var);

if(value == null) {

throw new RuntimeException("Unknown variable: " + var);

}

return value;

}

}

class IfNode implements Node {

private Node test;

private Node ifTrue;

private Node ifFalse;

public IfNode(Node a, Node b, Node c) {

test = a;

ifTrue = b;

ifFalse = c;

}

@Override

public Object eval() {

return (Boolean)test.eval() ? ifTrue.eval() : ifFalse.eval();

}

}

TWalker.g

tree grammar TWalker;

options {

tokenVocab=T;

ASTLabelType=CommonTree;

}

@members {

private java.util.Map memory = new java.util.HashMap();

}

walk returns [Node n]

: (statement {$n = $statement.n;})+

;

statement returns [Node n]

: ifStatement {$n = $ifStatement.n;}

| assignment {$n = null;}

;

assignment

: ^(ASSIGNMENT ID expression) {memory.put($ID.text, $expression.n.eval());}

;

ifStatement returns [Node n]

: ^(IF a=expression b=expression c=expression?) {$n = new IfNode($a.n, $b.n, $c.n);}

;

expression returns [Node n]

: ^(OR a=expression b=expression) {$n = new OrNode($a.n, $b.n);}

| ^(AND a=expression b=expression) {$n = new AndNode($a.n, $b.n);}

| ^('==' a=expression b=expression) {$n = new EqNode($a.n, $b.n);}

| ^('!=' a=expression b=expression) {$n = new NEqNode($a.n, $b.n);}

| ^('<=' a=expression b=expression) {$n = new LTEqNode($a.n, $b.n);}

| ^('

| ^('>=' a=expression b=expression) {$n = new GTEqNode($a.n, $b.n);}

| ^('>' a=expression b=expression) {$n = new GTNode($a.n, $b.n);}

| BOOLEAN {$n = new AtomNode(Boolean.valueOf($BOOLEAN.text));}

| NUMBER {$n = new AtomNode(Double.valueOf($NUMBER.text));}

| ID {$n = new VarNode(memory, $ID.text);}

;

如果您现在运行主类,并评估：

a = 3

b = 4

if b > a then

b==b

else

c==c

正在打印到控制台：

bart@hades:~/Programming/ANTLR/Demos/T$java -cp antlr-3.3.jar org.antlr.Tool T.g

bart@hades:~/Programming/ANTLR/Demos/T$java -cp antlr-3.3.jar org.antlr.Tool TWalker.g

bart@hades:~/Programming/ANTLR/Demos/T$javac -cp antlr-3.3.jar *.java

bart@hades:~/Programming/ANTLR/Demos/T$java -cp .:antlr-3.3.jar Main

true

但是,如果你检查b< a,导致执行else,你会看到以下内容：

Exception in thread "main" java.lang.RuntimeException: Unknown variable: c

at VarNode.eval(Main.java:140)

at EqNode.eval(Main.java:112)

at IfNode.eval(Main.java:160)

at Main.main(Main.java:11)

有关更复杂的语言结构(范围,函数等)的实现,请参阅my blog.

祝好运！