了解antlr4生成的解析上下文代码，找到在一个上下文中检测terminalNode的好方法

Question

G4文件部分为:

typeSpecifier
    :   ('void'
    |   'char'
    |   'short'
    |   'int'
    |   '__m128d'
    |   '__m128i')
    |   '__extension__' '(' ('__m128' | '__m128d' | '__m128i') ')'
    |   atomicTypeSpecifier
    |   structOrUnionSpecifier
    |   enumSpecifier
    |   typedefName
    |   '__typeof__' '(' constantExpression ')' // GCC extension
    ;

生成的代码是:

public static class TypeSpecifierContext extends ParserRuleContext {                                                     
    public AtomicTypeSpecifierContext atomicTypeSpecifier() {                                                            
        return getRuleContext(AtomicTypeSpecifierContext.class,0);                                                       
    }                                                                                                                    
    public StructOrUnionSpecifierContext structOrUnionSpecifier() {                                                      
        return getRuleContext(StructOrUnionSpecifierContext.class,0);                                                    
    }                                                                                                                    
    public EnumSpecifierContext enumSpecifier() {                                                                        
        return getRuleContext(EnumSpecifierContext.class,0);                                                             
    }                                                                                                                    
    public TypedefNameContext typedefName() {                                                                            
        return getRuleContext(TypedefNameContext.class,0);                                                               
    }                                                                                                                    
    public ConstantExpressionContext constantExpression() {                                                              
        return getRuleContext(ConstantExpressionContext.class,0);                                                        
    }                                                                                                                    
    public TypeSpecifierContext(ParserRuleContext parent, int invokingState) {                                           
        super(parent, invokingState);                                                                                    
    }                                                                                                                    
    @Override public int getRuleIndex() { return RULE_typeSpecifier; }                                                   
    @Override                                                                                                            
    public void enterRule(ParseTreeListener listener) {                                                                  
        if ( listener instanceof ProbeListener ) ((ProbeListener)listener).enterTypeSpecifier(this);                     
    }                                                                                                                    
    @Override                                                                                                            
    public void exitRule(ParseTreeListener listener) {                                                                   
        if ( listener instanceof ProbeListener ) ((ProbeListener)listener).exitTypeSpecifier(this);                      
    }                                                                                                                    
    @Override                                                                                                            
    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {                                                         
        if ( visitor instanceof ProbeVisitor ) return ((ProbeVisitor<? extends T>)visitor).visitTypeSpecifier(this);     
        else return visitor.visitChildren(this);                                                                         
    }                                                                                                                    
}                                                                                                                        

我正在尝试查看访问代码中的typeSpecifier是哪种类型:

TypeSpecifierContext typeSpecifier = ctx.typeSpecifier(); // ctx is parent context    
LOG.trace(String.format("typeSepcifier the start is %s the stop is %s" , typeSpecifier.getStart().getText()
                    , typeSpecifier.getStop().getText()));

我可以得到这样的输出:

typeSepcifier the start is int the stop is int

我觉得这个方法很丑，Antlr4能提供实现像instanceof IntTypeSpecifier这样的方法吗?

Answer 1

你可以使用访问者设计模式来访问ANTLR的AST并处理它，这样你甚至不需要使用instanceof.

final class Visitor extends YourGrammarParserBaseVisitor<String> { // The name of the base visitor should be <your grammar name> + 'ParserBaseVisitor'
    @Override
    public String visitTypeSpecifier(TypeSpecifierContext ctx) { // 'visit' + <name of the rule with the first letter to upper case>
        // Your code here
        return "the result";
    }
    // other visit methods for other rules
}

呼叫访问者:

new Visitor.visit(new YourGrammarParser(/* weird ANTLR stuff */).typeSpecifier());

如果你为int类型创建一个规则比如:

typeSpecifier
    : intTypeSpecifier
    | // the other rules
    ;
intTypeSpecifier : 'int';

您将能够为IntTypeSpecifierContext visitIntTypeSpecifier创建一个访问方法来轻松处理int类型。

所以代码应该是这样的:

final class Visitor extends YourGrammarParserBaseVisitor<String> {
    @Override
    public String visitTypeSpecifier(TypeSpecifierContext ctx) {
        return super();
    }
    @Override
    public String visitIntTypeSpecifier(IntTypeSpecifierContext ctx) {
        return 'int'; // or ctx.getText()
    }
    // Rest of the rules
}

现在纠正我，因为我可能是错的，但是你可以直接调用getText来查看typeSpecifier的类型(TypeSpecifierContext扩展RuleContext，它提供了这个方法)。