访问者模式程序不能正常工作

Question

我需要为计算器创建一个简单的编译器，我使用的是antlr4和Visitor-Pattern。这是我的语法文件Simple_Calculator.g4：

grammar Simple_Calculator;
program : statements ;
statements : statement | statements statement ;
statement : identifier '=' expr ';'                         #assign
      | 'begin' statements 'end'                            #brac
      | 'if' expr 'then' statement                          #if
      | 'if' expr 'then' statement 'else' statement                 #if_elset
      | 'while' expr 'do' statement                         #while
      | 'for' identifier '=' number ':' number 'do' statement           #for
      | 'print' identifier ';'                          #print
      ;
expr    : expr binop expr                               #ope
    | '!' expr                                  #invert
    | '(' expr ')'                                  #parenthesis
    | identifier                                    #identify
    | number                                    #num
    ;
binop   : '+'
    | '-'
    | '*'
    | '/'
    | '<'
    | '>'
    | '<='
    | '>='
    | '=='
    | '!='
    | '^'
    ;
identifier : STRING+('-'|STRING|INT)* ;                     
number  : INT+('.'INT+)? ;
STRING: [a-zA-Z]+ ;
INT : [0-9]+ ;
WS  : [ \t\r\n] -> skip ;

下面是MainVisitor extends Simple_CalculatorBaseVisitor类中的visitOpe和visitAssign方法：

public class MainVisitor extends Simple_CalculatorBaseVisitor<Object> {

@Override
    public Object visitAssign(Simple_CalculatorParser.AssignContext ctx) {
        String id = (String) (visit(ctx.identifier()));
        String value = (String)(visit(ctx.expr()));

        if (storage.containsKey(id)) {
            storage.replace(id, value);
        } else {
            storage.put(id, value);
        }
        return storage; //To change body of generated methods, choose Tools | Templates.
    } // end of visitAssign

@Override
    public Object visitOpe(Simple_CalculatorParser.OpeContext ctx) {
        String leftOperand = (String) visit(ctx.expr(0));
        String rightOperand = (String) visit(ctx.expr(1));
        /*if (rightOperand.matches("^\\d+$")) {
        return rightOperand;
        }*/
        String Operation = ctx.binop().getText();
        switch (Operation) {
            case "+": {
                leftOperand = setOperands(leftOperand);
                rightOperand = setOperands(rightOperand);
                return String.valueOf(Integer.parseInt(leftOperand) + Integer.parseInt(rightOperand));
            }
            case "-":
                leftOperand = setOperands(leftOperand);
                rightOperand = setOperands(rightOperand);
                return String.valueOf(Integer.parseInt(leftOperand) - Integer.parseInt(rightOperand));
            case "*":
                leftOperand = setOperands(leftOperand);
                rightOperand = setOperands(rightOperand);
                return String.valueOf(Integer.parseInt(leftOperand) * Integer.parseInt(rightOperand));
            case "/":
                leftOperand = setOperands(leftOperand);
                rightOperand = setOperands(rightOperand);
                return String.valueOf(Integer.parseInt(leftOperand) / Integer.parseInt(rightOperand));

// the rest possible conditions
    }

//other methods
}// end of visitOpe

问题是，当我想在赋值表达式中使用'-‘运算符时，当程序读取visitAssign中的行String value = (String)(visit(ctx.expr()));时，它不会在那之后访问visitOpe，而是返回整个表达式。例如，当我给程序：

i=5;
i=i+2;
print i;

作为输入，它工作得很好。它将i作为标识符存储在HashMap中，在第二行中，它将向其添加2个单位，并最终打印它的值。但是如果我将i=i+2;更改为i=i-2，它将存储初始值为5的i，但是在第二行中，它不通过visitOpe方法，而是返回"i-2“，并将其存储为i的值，最后打印出来。'*‘和'/’运算符作为加法可以很好地工作。这只是关于'-‘，我不知道是什么问题。那么，如何解决这个问题：

问候

Answer 1

使用该语法片段

identifier : STRING+('-'|STRING|INT)* ;      

i-2是有效的标识符。一种选择是从标识符中删除'-'。

所以：

identifier : STRING+(STRING|INT)* ;      

Answer 2

不同的观察，但如果您正在制作计算器或计算数学表达式的任何东西，您可能还会重新考虑您的binop优先级。在单个组中，从上到下对它们进行评估。它不像旧的BNF语法那样，人们玩花样，较高的优先运算符落在底部。因此，在您的示例中，像3+2*5这样的表达式将产生25而不是13，因为加法比乘法具有更高的优先级。请注意Bart Kier优先级中的优秀语法(Mu)是如何布局的：

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
 ;

最高优先级在顶部。