Python ANTLR4算术表达式访问者顺序操作

我试图理解在python版本的ANTLR4中访问者上下文是如何工作的

我正在使用Python3语法，并试图访问“arith_expr”

通过这个输入示例x=10+50-50我在访问者中有了这个上下文

len（ctx.term（））=3

是原子[10,50,50]的值

len(ctx.ADD()) = 1

len(ctx.MINUS()) = 1

接线员的命令是什么

arith_expr  
    : term (('+'|'-') term)*    
    ;

class Arith_exprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MBIParser.TermContext)
            else:
                return self.getTypedRuleContext(MBIParser.TermContext,i)


        def ADD(self, i:int=None):
            if i is None:
                return self.getTokens(MBIParser.ADD)
            else:
                return self.getToken(MBIParser.ADD, i)

        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(MBIParser.MINUS)
            else:
                return self.getToken(MBIParser.MINUS, i)

        def getRuleIndex(self):
            return MBIParser.RULE_arith_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArith_expr" ):
                listener.enterArith_expr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArith_expr" ):
                listener.exitArith_expr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArith_expr" ):
                return visitor.visitArith_expr(self)
            else:
                return visitor.visitChildren(self)

这是覆盖访问者定义

def visitArith_expr(self, ctx:MBIParser.Arith_exprContext):
    
    print(len(ctx.term())) #3
    self.visit(ctx.term(0)) #10
    self.visit(ctx.term(1)) #50
    self.visit(ctx.term(2)) #50

    print(len(ctx.ADD())) #1
    print(len(ctx.MINUS())) #1
    
    return self.visitChildren(ctx)

---

感谢您的解释

您可以在如下列表中收集所有运算符：

arith_expr
  : term (operators+=('+'|'-') term)*
  ;

expr
  : expr ('+' | '-') expr #add_expr
  | term                  #term_expr
  ;

运算符

是一个列表，包含所有运算符。然后，您可以在访问者中执行以下操作：

def visitArith_expr（自身，ctx）：
结果=自我访问（ctx术语（0））
对于范围内的i（len（ctx.operators））：
如果ctx.operators[i].type==MBILexer.ADD：
结果+=自我访视（ctx学期（i+1））
其他：
结果-=自我访视（ctx学期（i+1））
返回结果
def VisiterM（自身、ctx）：
返回int（ctx.getText（））

或者更好的做法是这样做：

arith_expr
  : term (operators+=('+'|'-') term)*
  ;

expr
  : expr ('+' | '-') expr #add_expr
  | term                  #term_expr
  ;

在这种情况下，访问者将变得更容易：

#expr（'+'|'-'）expr#add#u expr
def visitAdd_expr（自身，ctx）：
如果ctx.ADD（）不是无：
回访自访（ctx.expr（0））+自访（ctx.expr（1））
返回自我访问（ctx.expr（0））-自我访问（ctx.expr（1））
#术语表
def visitTerm_expr（自身，ctx）：
return self.visit（ctx.term（））
def VisiterM（自身、ctx）：
返回int（ctx.getText（））