java - ANTLR4语法: evaluation by listener/visitor or better with recursions?

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  :   [ \t\n\r]+ -> 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);
      }

这样说可能更清楚:我想使用递归函数来评估规则而不是编写单独的函数每条规则。而不是存储相关信息在我想调用的每个特定函数中一些评估函数，它沿着树向下(只要必要)并将信息返回给需要的地方。

这可以在 ANTLR4 中实现吗？

我在中找到了这种类型的递归执行逻辑的一些代码书《语言实现模式》，但是有一个 AST(抽象使用语法树)，但对我来说不是显然如何将其应用到上面的示例中(例如，从 where(或:if)可以继承 exec 函数，或者从 where可以访问 AST)。

Answer 1

为了简化这些操作，Antlr 使用 visitor pattern 实现了一个名为 YourGrammarNameBaseVisitor 的基类。下降到语法树的节点。 BaseVisitor 有一个名为 Visit 的方法，它或多或少地实现了用于选择接下来应该“访问”哪个规则的switch 。语法中的每个规则还有一个 VisitRuleName 方法。这些方法的基本实现将简单地下降到内部规则中，但是应该重写这些方法以在下降过程中采取一些操作或更改访问规则的顺序。

请注意，Visitor 类包含一个通用参数，该参数是每个 Visit 方法的返回值。有时，如果您正在创建一个非常具体的访问者(例如计算器语法)，那么放置像 Integer 这样的类型会很有用，但您始终可以将通用参数设置为 Object 或无效。

在您的示例语法中，我们可以有类似于以下的代码:

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);
    }
}