ANTLR4语法:由听众/访客评估或更好的递归评估

Question

我想用ANTLR4评估这个语法：

    grammar GrammarStack;
    prog: sentence+;
    sentence:
            ID 'owns' carDef  
    ;   
    carDef:
            'a' car ( 'and' 'a' car)* '.'
    ;
    car:
        type = ('Toyota'  | 'Ford' | 'Hyundai' | 'Chevrolet' | 'Opel' | 'BMW')
    ;
    COLON: ':' ;
    HASH: '#';
    SEMI: ';';
    ID: [a-zA-Z][a-zA-z0-9]+;
    WS  :   [ tnr]+ -> channel(HIDDEN);
    ANY_CHAR : . ; 

而侦听器的实现：

    import org.antlr.v4.runtime.ParserRuleContext;
    import org.antlr.v4.runtime.tree.ErrorNode;
    import org.antlr.v4.runtime.tree.TerminalNode;
    import java.util.Stack;

    public class MyGrammarStackListener extends GrammarStackBaseListener {
        Stack lifo = new Stack();
        @Override public void enterCarDef(GrammarStackParser.CarDefContext ctx) { 
        }
        @Override public void exitCarDef(GrammarStackParser.CarDefContext ctx) {
            GrammarStackParser.SentenceContext  sctx = (GrammarStackParser.SentenceContext )ctx.parent;
            System.out.println("this is the carDef for : " + sctx.ID().getText());
            for (int i=0;i<ctx.car().size();i++) {
                if (ctx.car(i)!=null) System.out.println("car no. " + (ctx.car().size()-i)       +  ": " + lifo.pop());
            }
            // here I should definitely also find out, if there are AND options
        }
        @Override public void enterCar(GrammarStackParser.CarContext ctx) {
             lifo.push(ctx.type.getText());
        }
    }

在此示例中，侦听器的实现很简单，虽然我需要一个堆栈来收集变量。

但是，如果汽车会更加复杂（比如说有些汽车会有依赖信息的定义），我更喜欢使用递归而不是侦听器。

喜欢

Object exec(int ruletype, Context ctx) {
    switch (ruleType) ..
      case CARDEF_ :  {
        CarStruct cs = exec(ctx.car);
      }

说得更清楚：我想使用递归函数来评估规则而不是编写单独的函数每个规则。而不是存储相关信息在我想调用的每个特定函数中一些 eval-function，它沿着树下行（只要必要）并将信息反馈给点，需要它的地方。

这可以在ANTLR4中实现吗？

我在书"语言实现模式"，但有一个AST（摘要）语法树）被使用，对我来说不是显而易见如何将其应用于上面的例子（例如，从哪里（或：如果）可以继承exec函数或在哪里可以访问 AST）。

Answer 1

为了简化这些操作，Antlr 实现了一个名为 YourGrammarNameBaseVisitor 的基类，使用访问者模式下降到语法树的节点。BaseVisitor有一个名为 Visit 的方法，它或多或少地实现了您选择接下来应该"访问"哪个规则switch。语法中的每个规则还有一个VisitRuleName方法。这些方法的基本实现将简单地下降到内部规则中，但应重写这些规则以在下降期间执行某些操作或更改规则的访问顺序。

请注意，Visitor 类包含一个泛型参数，该参数是每个 Visit 方法的返回。有时，如果您要创建非常具体的访问者（例如计算器语法），则放置像Integer这样的类型很有用，但是您始终可以将通用参数设置为Object或Void。

在您的示例语法中，我们可以有一个类似于以下内容的代码：

class MyVisitor extends GrammarStackBaseVisitor<Object> {
    @Override
    public Object visitCarDef(GrammarStackParser.CarDefContext ctx) {
        List<Car> cars = new ArrayList<Car>();
        // now for each car inside carDef
        for (GrammarStackParser.CarContext carCtx : ctx.car()) {
            Car car = (Car)visitCar(carCtx); // here is the recursion!
            cars.add(car);
        }
        return cars;
    }
    @Override
    public Object visitCar(GrammarStackParser.CarContext ctx) {
        String type = car.type().getText();
        return new Car(type);
    }
}