Пример #1
0
        public void CanIncludeBacktrackErrors()
        {
            var deepBacktrack = FailureMessage.Backtrack(new Position(3, 4),
                                                         FailureMessages.Empty
                                                         .With(FailureMessage.Expected("A"))
                                                         .With(FailureMessage.Expected("B")));

            var shallowBacktrack = FailureMessage.Backtrack(new Position(2, 3),
                                                            FailureMessages.Empty
                                                            .With(FailureMessage.Expected("C"))
                                                            .With(FailureMessage.Expected("D"))
                                                            .With(deepBacktrack));

            var unrelatedBacktrack = FailureMessage.Backtrack(new Position(1, 2),
                                                              FailureMessages.Empty
                                                              .With(FailureMessage.Expected("E"))
                                                              .With(FailureMessage.Expected("F")));

            FailureMessages.Empty
            .With(deepBacktrack)
            .ToString().ShouldBe("[(3, 4): A or B expected]");

            FailureMessages.Empty
            .With(shallowBacktrack)
            .ToString().ShouldBe("[(2, 3): C or D expected [(3, 4): A or B expected]]");

            FailureMessages.Empty
            .With(FailureMessage.Expected("G"))
            .With(FailureMessage.Expected("H"))
            .With(shallowBacktrack)
            .With(unrelatedBacktrack)
            .ToString().ShouldBe("G or H expected [(1, 2): E or F expected] [(2, 3): C or D expected [(3, 4): A or B expected]]");
        }
Пример #2
0
        /// <inheritdoc/>
        public override IGeneralReply ParseGenerally(TokenStream tokens)
        {
            var start       = tokens.Position;
            var reply       = _parser.ParseGenerally(tokens);
            var newPosition = reply.UnparsedTokens.Position;

            if (reply.Success || start == newPosition)
            {
                return(reply);
            }

            return(new GeneralFailure(tokens, FailureMessage.Backtrack(newPosition, reply.FailureMessages)));
        }
Пример #3
0
        /// <inheritdoc/>
        public override IReply <TValue> Parse(TokenStream tokens)
        {
            var start       = tokens.Position;
            var reply       = _parser.Parse(tokens);
            var newPosition = reply.UnparsedTokens.Position;

            if (reply.Success || start == newPosition)
            {
                return(reply);
            }

            return(new Failure <TValue>(tokens, FailureMessage.Backtrack(newPosition, reply.FailureMessages)));
        }
Пример #4
0
        public void CanIndicateErrorsWhichCausedBacktracking()
        {
            var             position = new Position(3, 4);
            FailureMessages failures = FailureMessages.Empty
                                       .With(FailureMessage.Expected("a"))
                                       .With(FailureMessage.Expected("b"));

            var failure = (BacktrackFailureMessage)FailureMessage.Backtrack(position, failures);

            failure.Position.ShouldBe(position);
            failure.Failures.ShouldBe(failures);
            failure.ToString().ShouldBe("(3, 4): a or b expected");
        }