Question

我正在尝试使用ANTLR为一种简单的编程语言创建解释器。到目前为止，它由打印和数字表达式组成。我创建了一个'simpleExpr'解析器规则来处理负数。我也尝试了其他方法，但这是唯一适合我的方法。但是，由于某种原因，即使我希望它访问我的“数字”规则，我的访客也输入了此规则。我真的认为，这不是访客的错，因为即使ANTLR绘制的树也显示了此行为。这很奇怪，但是没关系，但是我的问题是，当我尝试打印出简单加法的结果时，例如打印（1 + 2）;那么它不会执行此操作，而是输入“数字”规则而不是“加号”规则。

我的语法：

grammar BatshG;
/*
 * Parser Rules
 */
compileUnit: (expression | ( println ';') | ( print ';' ))+;
expression:     
                left=expression '/' right=simpleExpr #Divi
            |   left=expression '*' right=simpleExpr #Mult
            |   left=expression '-' right=simpleExpr #Minus
            |   left=expression '+' right=simpleExpr #Plus
            |   number=simpleExpr                    #Number
;
println: 'println' '(' argument=expression ')'; 
print: 'print' '(' argument=expression ')';
simpleExpr
      :   (MINUS)?
          (FLOAT | INTEGER)
      ;
MINUS: '-';
INTEGER: [0-9] [0-9]*;
DIGIT : [0-9]                       ;
FRAC : '.' DIGIT+                   ;
EXP : [eE] [-+]? DIGIT+  ;
FLOAT : DIGIT* FRAC EXP?             ;
WS: [ \n\t\r]+ -> channel(HIDDEN);

如果有帮助，这是ANTLR为

生成的可视化树

print(1+2);

更新：访客类别（如果有）：

public class BatshGVisitor : BatshGBaseVisitor<ResultValue>
{
    public ResultValue Result { get; set; }
    public StringBuilder OutputForPrint { get; set; }

    public override ResultValue VisitCompileUnit([NotNull] BatshGParser.CompileUnitContext context)
    {
        OutputForPrint = new StringBuilder("");
        var resultvalue = VisitChildren(context);
        Result = new ResultValue() { ExpType = "string", ExpValue = resultvalue.ExpValue };
        return Result;
    }

    public override ResultValue VisitPlus([NotNull] BatshGParser.PlusContext context)
    {
        var leftExp = VisitChildren(context.left);
        var rigthExp = VisitChildren(context.right);

        return new ResultValue()
        {
            ExpType = "number",
            ExpValue = (double)leftExp.ExpValue + (double)rigthExp.ExpValue
        };
    }

    //public override ResultValue VisitNumber([NotNull] BatshGParser.NumberContext context)
    //{
    //    return new ResultValue()
    //    {
    //        ExpType = "number",
    //        ExpValue = Double.Parse(context.GetChild(0).GetText() 
    //        + context.GetChild(1).GetText()
    //        + context.GetChild(2).GetText()
    //        , CultureInfo.InvariantCulture)
    //    };
    //}

    public override ResultValue VisitPrint([NotNull] BatshGParser.PrintContext context)
    {
        var viCh = VisitChildren(context.argument);
        var viChVa = viCh.ExpValue;
        string printInner = viChVa.ToString();
        var toPrint = new ResultValue()
        {
            ExpType = viCh.ExpType,
            ExpValue = printInner
        };
        OutputForPrint.Append(toPrint.ExpValue);
        return toPrint;
    }

    public override ResultValue VisitSimpleExpr([NotNull] BatshGParser.SimpleExprContext context)
    {
        string numberToConvert = "";
        if (context.ChildCount == 1)
        {
            numberToConvert = context.GetChild(0).GetText();
        }
        else if (context.GetChild(0).ToString() == "-")
        {
            if (context.ChildCount == 2)
            {
                numberToConvert = "-" + context.GetChild(1);
            }
            if (context.ChildCount == 4)
            {
                numberToConvert = context.GetChild(0).ToString() + context.GetChild(1).ToString() +
                    context.GetChild(2).ToString() + context.GetChild(3).ToString();
            }
        }

        return new ResultValue()
        {
            ExpType = "number",
            ExpValue = Double.Parse(numberToConvert, CultureInfo.InvariantCulture)
        };
    }

    protected override ResultValue AggregateResult(ResultValue aggregate, ResultValue nextResult)
    {
        if (aggregate == null)
            return new ResultValue()
            {
                ExpType = nextResult.ExpType,
                ExpValue = nextResult.ExpValue
            };
        if (nextResult == null)
        {
            return aggregate;
        }
        return null;
    }
}

我的语法有什么问题？谢谢！

Answer 1

在print语句的visit方法中，您有以下内容：

var viCh = VisitChildren(context.argument);

因此，假设您输入的是print(1+2);。然后context.argument将是PlusContext的{{1}}，而1+2的子项将是1的context.argument，NumberContext对象是{{ 1}}和2的Token对象。因此，通过调用+，您将访问那些孩子，这就是为什么它从不运行SimpleExpression并直接进入数字的原因。

通常，您很少想访问其他某个节点的子节点。通常，您想拜访自己的孩子，而不是跳过孩子而直接拜访大孩子。因此，您应该调用VisitChildren。

ANTLR的解析器输入“错误”规则

1 个答案: