C＃ANTLR4 DefaultErrorStrategy或自定义错误侦听器无法捕获无法识别的字符

Question

这很奇怪，但是DefaultErrorStrategy对于捕获流中无法识别的字符没有任何作用。我尝试了自定义错误策略，自定义错误侦听器和BailErrorStrategy-运气不好。

我的语法

grammar Polynomial;

parse           : canonical EOF
                ;

canonical       : polynomial+                                     #canonicalPolynom
                | polynomial+ EQUAL polynomial+                   #equality
                ;

polynomial      : SIGN? '(' (polynomial)* ')'                     #parens
                | monomial                                        #monom
                ;

monomial        : SIGN? coefficient? VAR ('^' INT)?               #addend
                | SIGN? coefficient                               #number
                ;

coefficient             : INT | DEC;

INT                     : ('0'..'9')+;
DEC                     : INT '.' INT;
VAR                     : [a-z]+;
SIGN                    : '+' | '-';
EQUAL                   : '=';
WHITESPACE              : (' '|'\t')+ -> skip;

并且我输入23*44=12或@1234

我期望我的解析器为语法中未定义的字符*或@抛出不匹配的标记或任何类型的异常。

相反，我的解析器只是跳过*或@并遍历一棵不存在的树。

我在处理程序函数中调用词法分析器，解析器的东西。

private static (IParseTree tree, string parseErrorMessage) TryParseExpression(string expression)
        {
            ICharStream stream = CharStreams.fromstring(expression);
            ITokenSource lexer = new PolynomialLexer(stream);

            ITokenStream tokens = new CommonTokenStream(lexer);
            PolynomialParser parser = new PolynomialParser(tokens);

            //parser.ErrorHandler = new PolynomialErrorStrategy(); -> I tried custom error strategy
            //parser.RemoveErrorListeners();
            //parser.AddErrorListener(new PolynomialErrorListener()); -> I tried custom error listener
            parser.BuildParseTree = true;

            try
            {
                var tree = parser.canonical();
                return (tree, string.Empty);
            }
            catch (RecognitionException re)
            {
                return (null, re.Message);
            }
            catch (ParseCanceledException pce)
            {
                return (null, pce.Message);
            }
        }            

我尝试添加自定义错误侦听器。

public class PolynomialErrorListener : BaseErrorListener
    {
        private const string Eof = "EOF";

        public override void SyntaxError(TextWriter output, IRecognizer recognizer, IToken offendingSymbol, int line, int charPositionInLine, string msg,
            RecognitionException e)
        {
            if (msg.Contains(Eof))
            {
                throw new ParseCanceledException($"{GetSyntaxErrorHeader(charPositionInLine)}. Missing an expression after '=' sign");
            }

            if (e is NoViableAltException || e is InputMismatchException)
            {
                throw new ParseCanceledException($"{GetSyntaxErrorHeader(charPositionInLine)}. Probably, not closed operator");
            }

            throw new ParseCanceledException($"{GetSyntaxErrorHeader(charPositionInLine)}. {msg}");
        }

        private static string GetSyntaxErrorHeader(int errorPosition)
        {
            return $"Expression is invalid. Input is not valid at {--errorPosition} position";
        }
    }

此后，我尝试实施自定义错误策略。

public class PolynomialErrorStrategy : DefaultErrorStrategy
    {
        public override void ReportError(Parser recognizer, RecognitionException e)
        {
            throw e;
        }

        public override void Recover(Parser recognizer, RecognitionException e)
        {
            for (ParserRuleContext context = recognizer.Context; context != null; context = (ParserRuleContext) context.Parent) {
                context.exception = e;
            }

            throw new ParseCanceledException(e);
        }

        public override IToken RecoverInline(Parser recognizer)
        {
            InputMismatchException e = new InputMismatchException(recognizer);
            for (ParserRuleContext context = recognizer.Context; context != null; context = (ParserRuleContext) context.Parent) {
                context.exception = e;
            }

            throw new ParseCanceledException(e);
        }

        protected override void ReportInputMismatch(Parser recognizer, InputMismatchException e)
        {
            string msg = "mismatched input " + GetTokenErrorDisplay(e.OffendingToken);
            // msg += " expecting one of " + e.GetExpectedTokens().ToString(recognizer.());
            RecognitionException ex = new RecognitionException(msg, recognizer, recognizer.InputStream, recognizer.Context);
            throw ex;
        }

        protected override void ReportMissingToken(Parser recognizer)
        {
            BeginErrorCondition(recognizer);
            IToken token = recognizer.CurrentToken;
            IntervalSet expecting = GetExpectedTokens(recognizer);
            string msg = "missing " + expecting.ToString() + " at " + GetTokenErrorDisplay(token);
            throw new RecognitionException(msg, recognizer, recognizer.InputStream, recognizer.Context);
        }
    }

是否有我忘记在解析器中指定的标志或语法不正确？

我在IDE中使用ANTLR插件的有趣的事情，当我在此处测试语法时，此插件正确地显示为line 1:2 token recognition error at: '*'

完整源代码：https://github.com/EvgeniyZ/PolynomialCanonicForm

我正在使用ANTLR 4.8-complete.jar

编辑

我试图添加语法规则

parse           : canonical EOF
                ;

这里仍然没有运气

Answer 1

如果执行此操作会发生什么：

parse
 : canonical EOF
 ;

并且还要调用此规则：

var tree = parser.parse();

通过添加EOF令牌（输入的结尾），您将强制解析器使用所有令牌，当解析器无法正确处理它们时，这将导致错误。

我在IDE中使用ANTLR插件的有趣的事情，当我在此处测试语法时，此插件正确地显示为line 1:2 token recognition error at: '*'

这就是词法分析器在std.err流上发出的内容。词法分析器仅报告此警告，然后继续进行。因此，词法分析器只会忽略这些字符，因此永远不会在解析器中结束。如果在词法分析器的末尾添加以下行：

// Fallback rule: matches any single character if not matched by another lexer rule
UNKNOWN : . ;

然后*和@字符将作为UNKNOWN令牌发送到解析器，然后将导致识别错误。