使用侦听器的ANTLR中的If/else语句

我正在为一个学校项目创建一种简单的编程语言。我使用ANTLR 4从我的语法生成词法分析器和解析器。到目前为止，我一直在使用antlr的侦听器模式来应用编程语言的实际功能。

现在我想实现if/else语句，但我不确定这些可以在使用侦听器模式时实际实现，因为ANTLR决定在使用侦听器时以哪种顺序遍历解析树，我想象if/else语句的实现将需要根据语句中的哪个条件在解析树中跳转。

谁能告诉我是否可以使用ANTLR实现if/else语句，或者我是否必须自己实现访问者模式?另外，谁能给出一个非常简单的例子来实现这些语句?

默认情况下，ANTLR 4生成侦听器。但是如果给org.antlr.v4.Tool指定命令行参数-visitor, ANTLR会为您生成访问者类。它们的工作方式与侦听器非常相似，但可以让您更好地控制哪些(子)树被遍历/访问。如果您想要排除某些(子)树(如else/if块，就像您的情况一样)，这特别有用。虽然这个可以使用侦听器来完成，但是使用访问者来完成要干净得多。使用侦听器，您需要引入全局变量来跟踪(子)树是否需要求值，哪些不需要。

碰巧的是，我正在做一个小的ANTLR 4教程。它还没有完成，但我将发布一个小的工作示例，演示这些访问者类和if语句结构的使用。

<标题> 1。语法

下面是一个简单的语法，支持基本表达式，if -， while -和log -语句:

Mu.g4

grammar Mu;
parse
 : block EOF
 ;
block
 : stat*
 ;
stat
 : assignment
 | if_stat
 | while_stat
 | log
 | OTHER {System.err.println("unknown char: " + $OTHER.text);}
 ;
assignment
 : ID ASSIGN expr SCOL
 ;
if_stat
 : IF condition_block (ELSE IF condition_block)* (ELSE stat_block)?
 ;
condition_block
 : expr stat_block
 ;
stat_block
 : OBRACE block CBRACE
 | stat
 ;
while_stat
 : WHILE expr stat_block
 ;
log
 : LOG expr SCOL
 ;
expr
 : expr POW<assoc=right> expr           #powExpr
 | MINUS expr                           #unaryMinusExpr
 | NOT expr                             #notExpr
 | expr op=(MULT | DIV | MOD) expr      #multiplicationExpr
 | expr op=(PLUS | MINUS) expr          #additiveExpr
 | expr op=(LTEQ | GTEQ | LT | GT) expr #relationalExpr
 | expr op=(EQ | NEQ) expr              #equalityExpr
 | expr AND expr                        #andExpr
 | expr OR expr                         #orExpr
 | atom                                 #atomExpr
 ;
atom
 : OPAR expr CPAR #parExpr
 | (INT | FLOAT)  #numberAtom
 | (TRUE | FALSE) #booleanAtom
 | ID             #idAtom
 | STRING         #stringAtom
 | NIL            #nilAtom
 ;
OR : '||';
AND : '&&';
EQ : '==';
NEQ : '!=';
GT : '>';
LT : '<';
GTEQ : '>=';
LTEQ : '<=';
PLUS : '+';
MINUS : '-';
MULT : '*';
DIV : '/';
MOD : '%';
POW : '^';
NOT : '!';
SCOL : ';';
ASSIGN : '=';
OPAR : '(';
CPAR : ')';
OBRACE : '{';
CBRACE : '}';
TRUE : 'true';
FALSE : 'false';
NIL : 'nil';
IF : 'if';
ELSE : 'else';
WHILE : 'while';
LOG : 'log';
ID
 : [a-zA-Z_] [a-zA-Z_0-9]*
 ;
INT
 : [0-9]+
 ;
FLOAT
 : [0-9]+ '.' [0-9]* 
 | '.' [0-9]+
 ;
STRING
 : '"' (~["rn] | '""')* '"'
 ;
COMMENT
 : '#' ~[rn]* -> skip
 ;
SPACE
 : [ trn] -> skip
 ;
OTHER
 : . 
 ;

现在让我们假设你想解析和计算这样的输入:

test.mu

a = true;
b = false;
if a && b {
  log "1 :: a=" + a +", b=" + b;
}
else if a || b {
  log "2 :: a=" + a +", b=" + b;
}
else {
  log "3 :: a=" + a +", b=" + b;
}
log "Done!";

<标题> 2。客人我

首先生成解析器和访问者类:

java -cp antlr-4.0-complete.jar org.antlr.v4.Tool Mu.g4 -visitor

上面的命令将生成文件MuBaseVisitor<T>。这是我们要用自己的逻辑扩展的类:

EvalVisitor.java

public class EvalVisitor extends MuBaseVisitor<Value> {
    // ...
}

其中Value只是我们语言的任何类型(String, Boolean, Double)的包装:

Value.java

public class Value {
    public static Value VOID = new Value(new Object());
    final Object value;
    
    public Value(Object value) {
        this.value = value;
    }
    public Boolean asBoolean() {
        return (Boolean)value;
    }
    public Double asDouble() {
        return (Double)value;
    }
    public String asString() {
        return String.valueOf(value);
    }
    public boolean isDouble() {
        return value instanceof Double;
    }
    @Override
    public int hashCode() {
        if(value == null) {
            return 0;
        }
        return this.value.hashCode();
    }
    @Override
    public boolean equals(Object o) {
        if(value == o) {
            return true;
        }
        if(value == null || o == null || o.getClass() != this.getClass()) {
            return false;
        }
        Value that = (Value)o;
        return this.value.equals(that.value);
    }
    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

<标题> 3。测试我要测试这些类，使用以下Main类:

Main.java

import org.antlr.v4.runtime.ANTLRFileStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
public class Main {
    public static void main(String[] args) throws Exception {
        MuLexer lexer = new MuLexer(new ANTLRFileStream("test.mu"));
        MuParser parser = new MuParser(new CommonTokenStream(lexer));
        ParseTree tree = parser.parse();
        EvalVisitor visitor = new EvalVisitor();
        visitor.visit(tree);
    }
}

，编译并运行源文件:

javac -cp antlr-4.0-complete.jar *.java
java -cp .:antlr-4.0-complete.jar Main

(在Windows上，最后一个命令是:java -cp .;antlr-4.0-complete.jar Main)

运行Main之后，什么都没有发生(当然?)这是因为我们没有在EvalVisitor类中实现任何规则。为了能够正确地评估文件test.mu，我们需要为以下规则提供适当的实现:

if_stat
andExpr
orExpr
plusExpr
assignment
idAtom
booleanAtom
stringAtom
log

# 4。参观者II &测试二

下面是这些规则的实现:

import org.antlr.v4.runtime.misc.NotNull;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class EvalVisitor extends MuBaseVisitor<Value> {
    // used to compare floating point numbers
    public static final double SMALL_VALUE = 0.00000000001;
    // store variables (there's only one global scope!)
    private Map<String, Value> memory = new HashMap<String, Value>();
    // assignment/id overrides
    @Override
    public Value visitAssignment(MuParser.AssignmentContext ctx) {
        String id = ctx.ID().getText();
        Value value = this.visit(ctx.expr());
        return memory.put(id, value);
    }
    @Override
    public Value visitIdAtom(MuParser.IdAtomContext ctx) {
        String id = ctx.getText();
        Value value = memory.get(id);
        if(value == null) {
            throw new RuntimeException("no such variable: " + id);
        }
        return value;
    }
    // atom overrides
    @Override
    public Value visitStringAtom(MuParser.StringAtomContext ctx) {
        String str = ctx.getText();
        // strip quotes
        str = str.substring(1, str.length() - 1).replace("""", """);
        return new Value(str);
    }
    @Override
    public Value visitNumberAtom(MuParser.NumberAtomContext ctx) {
        return new Value(Double.valueOf(ctx.getText()));
    }
    @Override
    public Value visitBooleanAtom(MuParser.BooleanAtomContext ctx) {
        return new Value(Boolean.valueOf(ctx.getText()));
    }
    @Override
    public Value visitNilAtom(MuParser.NilAtomContext ctx) {
        return new Value(null);
    }
    // expr overrides
    @Override
    public Value visitParExpr(MuParser.ParExprContext ctx) {
        return this.visit(ctx.expr());
    }
    @Override
    public Value visitPowExpr(MuParser.PowExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        return new Value(Math.pow(left.asDouble(), right.asDouble()));
    }
    @Override
    public Value visitUnaryMinusExpr(MuParser.UnaryMinusExprContext ctx) {
        Value value = this.visit(ctx.expr());
        return new Value(-value.asDouble());
    }
    @Override
    public Value visitNotExpr(MuParser.NotExprContext ctx) {
        Value value = this.visit(ctx.expr());
        return new Value(!value.asBoolean());
    }
    @Override
    public Value visitMultiplicationExpr(@NotNull MuParser.MultiplicationExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case MuParser.MULT:
                return new Value(left.asDouble() * right.asDouble());
            case MuParser.DIV:
                return new Value(left.asDouble() / right.asDouble());
            case MuParser.MOD:
                return new Value(left.asDouble() % right.asDouble());
            default:
                throw new RuntimeException("unknown operator: " + MuParser.tokenNames[ctx.op.getType()]);
        }
    }
    @Override
    public Value visitAdditiveExpr(@NotNull MuParser.AdditiveExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case MuParser.PLUS:
                return left.isDouble() && right.isDouble() ?
                        new Value(left.asDouble() + right.asDouble()) :
                        new Value(left.asString() + right.asString());
            case MuParser.MINUS:
                return new Value(left.asDouble() - right.asDouble());
            default:
                throw new RuntimeException("unknown operator: " + MuParser.tokenNames[ctx.op.getType()]);
        }
    }
    @Override
    public Value visitRelationalExpr(@NotNull MuParser.RelationalExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case MuParser.LT:
                return new Value(left.asDouble() < right.asDouble());
            case MuParser.LTEQ:
                return new Value(left.asDouble() <= right.asDouble());
            case MuParser.GT:
                return new Value(left.asDouble() > right.asDouble());
            case MuParser.GTEQ:
                return new Value(left.asDouble() >= right.asDouble());
            default:
                throw new RuntimeException("unknown operator: " + MuParser.tokenNames[ctx.op.getType()]);
        }
    }
    @Override
    public Value visitEqualityExpr(@NotNull MuParser.EqualityExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        switch (ctx.op.getType()) {
            case MuParser.EQ:
                return left.isDouble() && right.isDouble() ?
                        new Value(Math.abs(left.asDouble() - right.asDouble()) < SMALL_VALUE) :
                        new Value(left.equals(right));
            case MuParser.NEQ:
                return left.isDouble() && right.isDouble() ?
                        new Value(Math.abs(left.asDouble() - right.asDouble()) >= SMALL_VALUE) :
                        new Value(!left.equals(right));
            default:
                throw new RuntimeException("unknown operator: " + MuParser.tokenNames[ctx.op.getType()]);
        }
    }
    @Override
    public Value visitAndExpr(MuParser.AndExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        return new Value(left.asBoolean() && right.asBoolean());
    }
    @Override
    public Value visitOrExpr(MuParser.OrExprContext ctx) {
        Value left = this.visit(ctx.expr(0));
        Value right = this.visit(ctx.expr(1));
        return new Value(left.asBoolean() || right.asBoolean());
    }
    // log override
    @Override
    public Value visitLog(MuParser.LogContext ctx) {
        Value value = this.visit(ctx.expr());
        System.out.println(value);
        return value;
    }
    // if override
    @Override
    public Value visitIf_stat(MuParser.If_statContext ctx) {
        List<MuParser.Condition_blockContext> conditions =  ctx.condition_block();
        boolean evaluatedBlock = false;
        for(MuParser.Condition_blockContext condition : conditions) {
            Value evaluated = this.visit(condition.expr());
            if(evaluated.asBoolean()) {
                evaluatedBlock = true;
                // evaluate this block whose expr==true
                this.visit(condition.stat_block());
                break;
            }
        }
        if(!evaluatedBlock && ctx.stat_block() != null) {
            // evaluate the else-stat_block (if present == not null)
            this.visit(ctx.stat_block());
        }
        return Value.VOID;
    }
    // while override
    @Override
    public Value visitWhile_stat(MuParser.While_statContext ctx) {
        Value value = this.visit(ctx.expr());
        while(value.asBoolean()) {
            // evaluate the code block
            this.visit(ctx.stat_block());
            // evaluate the expression
            value = this.visit(ctx.expr());
        }
        return Value.VOID;
    }
}

当您重新编译并运行Main时，将打印以下内容到您的控制台:

2 :: a=true, b=false
Done!

所有其他规则的实现，参见:https://github.com/bkiers/Mu

编辑

来自@pwwpche，在评论中:

对于使用jdk1.8并且遇到IndexOutOfBoundsException, antlr 4.0的用户与jdk1.8不兼容。下载antlr-4.6-complete.jar将expr POW<assoc=right> expr替换为<assoc=right>expr POW expr消除错误和警告。

Mu.g4

test.mu

EvalVisitor.java

Value.java

Main.java

编辑

相关内容

最新更新

热门标签：