private static void RunJsonExample()
{
{
var sdfa =
from start in StartAtAny.ToGenericParser().WithPosition()
from result in "abc".ToParserInvariant().ToGenericParser().WithPosition()
select(result, start.Position).WithPosition() into result
from a in AnyChar.Reversed().WithInputTransform <char, char, Generic.ReversedReadOnlyList <char, IReadOnlyList <char> >, Generic.InputReverse <char, Generic.ReversedReadOnlyList <char, IReadOnlyList <char> > > >(default).Times(4, 4)
// WAT THE F*CK, F*CK COMBINATORS, F*CK MY LIFE, F****CK!
public static Parser <T> OrPreview <T>(this Parser <T> first, Parser <T> other)
where T : BaseSyntax, IPositionAware <T>, IPassiveParseTransition, new() => i =>
{
var fr = first(i);
var sr = other(i);
switch (fr.WasSuccessful)
{
case false when !sr.WasSuccessful && i.Memos.IsEnabled(MemoFlags.NextFail):
i.Memos.Disable(MemoFlags.NextFail);
return(sr.IfFailure(sf => DetermineBestError(fr, sf)));
case true:
fr.Remainder.Memos.Enable(MemoFlags.NextFail);
break;
}
if (fr.WasSuccessful)
{
return(Success(fr.Value, fr.Remainder));
}
if (sr.WasSuccessful)
{
return(Success(sr.Value, sr.Remainder));
}
if (!i.IsEffort(fr, sr))
{
return(sr.IfFailure(sf => DetermineBestError(fr, sf)));
}
// read until terminator char
var r = AnyChar.Until(Char(';'))(i);
var bestResult = DetermineBestError(fr, sr);
var error = new T();
error.SetPos(FromInput(bestResult.Remainder), r.Remainder.Position - i.Position);
error.Error = new PassiveParseError(bestResult.Message, bestResult.Expectations);
r.Remainder.Memos.Enable(MemoFlags.NextFail);
return(Success(error, r.Remainder));
};
public static Parser <T> PreviewMultiple <T>(this Parser <T> first, params Parser <T>[] others)
where T : BaseSyntax, IPositionAware <T>, IPassiveParseTransition, new()
{
return(i =>
{
var results = new[] { first }.Concat(others).Select(x => x(i)).ToArray();
var succeeded = results.FirstOrDefault(x => x.WasSuccessful);
if (succeeded is not null)
{
return Success(succeeded.Value, succeeded.Remainder);
}
if (results.All(x => !x.WasSuccessful))
{
if (i.Memos.IsEnabled(MemoFlags.NextFail))
{
i.Memos.Disable(MemoFlags.NextFail);
return DetermineBestErrors(results);
}
}
if (!i.IsEffort(results))
{
return DetermineBestErrors(results);
}
var r = AnyChar.Until(Char(';'))(i);
var error = new T();
error.SetPos(FromInput(i), r.Remainder.Position - i.Position);
var bestResult = DetermineBestErrors(results);
error.Error = new PassiveParseError(bestResult.Message, bestResult.Expectations);
r.Remainder.Memos.Enable(MemoFlags.NextFail);
return Success(error, r.Remainder);
});
}
public void Visit(AnyChar target)
{
stack.Push(NFA.AnyCharacter());
}
public void TestStatics()
{
ut.Assert.AreEqual(Text("abc", ".txt").Expression, @"abc\.txt");
ut.Assert.AreEqual(Text("abc", ".txt")[1].Expression, @"(?:abc\.txt){1}");
ut.Assert.AreEqual(Group("abc", ".txt").Expression, @"(abc\.txt)");
ut.Assert.AreEqual(NamedGroup("group1", "abc", ".txt").AtLeast(3).Expression, @"(?'group1'abc\.txt){3,}");
ut.Assert.AreEqual(CaptureGroup("group1", "abc", ".txt").NoneOrOnce(RepeatMode.Lazy).Expression, @"(?'group1'abc\.txt)??");
var g = NamedGroup("group1", NewLine.OnceOrMore());
ut.Assert.AreEqual((g + BackRef("group1")).Expression, @"(?'group1'(?:\n|\r\n)+)\k'group1'");
ut.Assert.AreEqual((g + BackRef(1)).Expression, @"(?'group1'(?:\n|\r\n)+)\1");
ut.Assert.AreEqual(AtomicGroup("abc", ".txt").NoneOrMany().Expression, @"(?>abc\.txt)*");
ut.Assert.AreEqual(Greedy("abc", ".txt").Maybe().Expression, @"(?>abc\.txt)?");
ut.Assert.AreEqual(NonBacktracking("abc", ".txt").OnceOrMore().Expression, @"(?>abc\.txt)+");
ut.Assert.AreEqual(NoBacktrack("abc", ".txt").Expression, @"(?>abc\.txt)");
ut.Assert.AreEqual(NonCapturingGroup("abc", ".txt").Expression, @"(?:abc\.txt)");
ut.Assert.AreEqual(Enclose("abc", ".txt")[1].Expression, @"(?:abc\.txt){1}");
ut.Assert.AreEqual(BalancingGroup("group1", "abc.txt").Expression, @"(?'-group1'abc\.txt)");
ut.Assert.AreEqual(BalancingGroup("group1", "group2", "abc.txt").Expression, @"(?'group2-group1'abc\.txt)");
ut.Assert.AreEqual(LookAhead("abc")[2, 7].Expression, "(?=abc)");
ut.Assert.AreEqual(NegativeLookAhead("abc", "efg").Expression, "(?!abcefg)");
ut.Assert.AreEqual(LookBehind("abc".Repeat(5)).Expression, "(?<=(?:abc){5})");
ut.Assert.AreEqual(NegativeLookBehind("abc".AsItIs() + "d" | "f").Expression, "(?<!abcd|f)");
ut.Assert.AreEqual(AssertNextIs("abc").Expression, "(?=abc)");
ut.Assert.AreEqual(AssertNextIsNot("abc", "efg")[2, 7].Expression, "(?!abcefg)");
ut.Assert.AreEqual(AssertPreviousIs("abc".Repeat(5)).Expression, "(?<=(?:abc){5})");
ut.Assert.AreEqual(AssertPreviousIsNot("abc".AsItIs() + "d" | "f").Expression, "(?<!abcd|f)");
var p = "q" + AssertNextIs("u" + Group(AnyChar)) +
AnyChar.Repeat(3) + BackRef(1);
ut.Assert.AreEqual(p.Expression, @"q(?=u(.)).{3}\1");
p = "qu" + Group(AnyChar) + AnyChar + BackRef(1);
ut.Assert.AreEqual(p.Expression, @"qu(.).\1");
p = "qu" + Group(AnyChar) + AnyChar + AssertNextIs(BackRef(1));
ut.Assert.AreEqual(p.Expression, @"qu(.).(?=\1)");
ut.Assert.AreEqual(Intersection(Unicode.Arabic, Unicode.Letter).Expression, @"(?=\p{IsArabic})\p{L}");
ut.Assert.AreEqual(Difference(Unicode.Letter, Unicode.Arabic).Expression, @"(?!\p{IsArabic})\p{L}");
var ag = IfExists("group1").ThenMatch("abc");
ut.Assert.AreEqual(ag.Expression, "(?(group1)abc)");
ag = ag.ElseMatch("x");
ut.Assert.AreEqual(ag.Expression, "(?(group1)abc|x)");
ag = Check(1).YesPattern("abc");
ut.Assert.AreEqual(ag.Expression, "(?(1)abc)");
ag = ag.NoPattern("x");
ut.Assert.AreEqual(ag.Expression, "(?(1)abc|x)");
ag = Assert(StartOfText).YesPattern("abc");
ut.Assert.AreEqual(ag.Expression, @"(?(\A)abc)");
ag = ag.NoPattern("x");
ut.Assert.AreEqual(ag[2, 3].Expression, @"(?(\A)abc|x){2,3}");
ut.Assert.AreEqual(OptionsGroup()[1].Expression, "");
var op = new OptionsGroupPattern().IgnoreCase().Multiline(false);
ut.Assert.AreEqual(op.Expression, "(?i-m)");
p = OptionsGroup().SetAll(true).OnceOrMore();
ut.Assert.AreEqual(p.Expression, "(?imnsx)");
op = Options.SetAll(false);
ut.Assert.AreEqual(op.Expression, "(?-imnsx)");
op = Options.SetAll(null);
ut.Assert.AreEqual(op.Expression, "");
p = OptionsGroup("abc")[2, 3];
ut.Assert.AreEqual(p.Expression, "(abc)");
ut.Assert.AreEqual(Comment("Test").Expression, @"(?#Test)");
var LineComments = WithLineComments(
("abc", "string"),
(Unicode.Arabic, "Arabic letter"))[2];
[Fact] public void ParseAnyChar() => AnyChar.ParseString("x").ShouldBe('x');
