public void LazyTest()
{
var throwException = new Func <Parser <Char, Char> >(() =>
{
throw new InvalidOperationException();
});
Assert.Throws(typeof(InvalidOperationException), () =>
Combinator.Or(
Chars.Any(),
throwException())
.Run("inputString".AsStream()));
Combinator.Or(
Chars.Any(),
Combinator.Lazy(throwException))
.Run("inputString".AsStream())
.Case(
failure: (restStream, _) => Assert.Fail(),
success: (restStream, value) =>
{
Assert.AreEqual('i', value);
Assert.True(restStream.Current.HasValue);
Assert.AreEqual('n', restStream.Current.Value.Item0);
Assert.AreEqual(1, restStream.Current.Value.Item1.Line);
Assert.AreEqual(2, restStream.Current.Value.Item1.Column);
});
}
private static void InitializeV04Parser()
{
var space = Chars.OneOf('\t', ' ').Ignore();
var spaces = space.Many0().Ignore();
var spacesOrNewlines = Chars.OneOf('\t', ' ', '\r', '\n').Many0().Ignore();
var newline = Combinator.Choice(
Chars.Sequence("\r\n"),
Chars.Sequence("\r"),
Chars.Sequence("\n")
).Ignore();
var newlineOrEof = newline.Or(Chars.EndOfInput()).Ignore();
var notNewlineChar = Chars.NoneOf('\r', '\n');
var comment = notNewlineChar.Many0()
.Between(Chars.Satisfy('#').Ignore(), newlineOrEof)
.Select(c => new Comment(c));
var newlineOrComment = newlineOrEof.Select(_ => (Comment)null).Or(comment);
var escaped = Chars.Satisfy('\\').Bindr(Combinator.Choice(
Chars.Satisfy('b').Select(_ => "\b"),
Chars.Satisfy('t').Select(_ => "\t"),
Chars.Satisfy('n').Select(_ => "\n"),
Chars.Satisfy('f').Select(_ => "\f"),
Chars.Satisfy('r').Select(_ => "\r"),
Chars.Sequence("\""),
//Chars.Sequence("/"),
Chars.Sequence("\\"),
Chars.Satisfy('u').Bindr(Chars.Hex().Repeat(4))
.Or(Chars.Satisfy('U').Bindr(Chars.Hex().Repeat(8)))
.Select(c => char.ConvertFromUtf32(Convert.ToInt32(string.Concat(c), 16)))
));
var newlineEscape = Combinator.Choice(Chars.Sequence("\\\r\n"), Chars.Sequence("\\\r"), Chars.Sequence("\\\n"))
.Bindr(spacesOrNewlines).Select(_ => "");
var basicString = Chars.NoneOf('\r', '\n', '"', '\\').Select(c => c.ToString())
.Or(escaped).Many0().Between(Chars.Satisfy('"').Ignore(), Chars.Satisfy('"').Ignore())
.Select(c => new TomlValue(TomlItemType.BasicString, c.Unfold()));
var threeQuotes = Chars.Sequence("\"\"\"").Ignore();
var multilineBasicStringChar = Combinator.Choice(
Chars.NoneOf('\\', '"').Select(c => c.ToString()),
escaped, newlineEscape
);
var multilineBasicString = Combinator.Choice(
multilineBasicStringChar,
Combinator.Sequence(Chars.Sequence('"'), multilineBasicStringChar).Select(Unfold),
Combinator.Sequence(Chars.Sequence("\"\""), multilineBasicStringChar).Select(Unfold)
).Many0().Between(threeQuotes, threeQuotes)
.Select(c => new TomlValue(TomlItemType.MultilineBasicString, c.Unfold().RemoveFirstNewLine()));
var literalString = Chars.NoneOf('\r', '\n', '\'').Many0()
.Between(Chars.Satisfy('\'').Ignore(), Chars.Satisfy('\'').Ignore())
.Select(c => new TomlValue(TomlItemType.LiteralString, string.Concat(c)));
var threeLiteralQuotes = Chars.Sequence("'''").Ignore();
var multilineLiteralStringChar = Chars.NoneOf('\'');
var multilineLiteralString = Combinator.Choice(
multilineLiteralStringChar.Select(c => c.ToString()),
Combinator.Sequence(Chars.Satisfy('\''), multilineLiteralStringChar),
Chars.Sequence("''").Bindr(multilineLiteralStringChar).Select(c => string.Concat("''", c))
).Many0().Between(threeLiteralQuotes, threeLiteralQuotes)
.Select(c => new TomlValue(TomlItemType.MultilineLiteralString, c.Unfold().RemoveFirstNewLine()));
var sign = Chars.OneOf('+', '-').Optional().Select(o => o.Case(() => "", c => c.ToString()));
var digit = Chars.Satisfy(c => c >= '0' && c <= '9');
var digits = digit.Many1();
var digitsWithUnderscores = digits.SepBy1(Chars.Satisfy('_').Ignore()).Select(Unfold);
var signedDigitsWithUnderscores = sign.Append(digitsWithUnderscores);
var integer = signedDigitsWithUnderscores.Select(x => new TomlValue(TomlItemType.Integer, string.Concat(x)));
var floatv = Combinator.Choice(
signedDigitsWithUnderscores.Append(Chars.Satisfy('.')).Append(digitsWithUnderscores),
signedDigitsWithUnderscores.Append(Chars.Sequence(".").Append(digitsWithUnderscores).Optional())
.Append(Chars.OneOf('e', 'E')).Append(signedDigitsWithUnderscores)
).Select(x => new TomlValue(TomlItemType.Float, string.Concat(x)));
var boolv = Chars.Sequence("true").Select(_ => true)
.Or(Chars.Sequence("false").Select(_ => false))
.Select(b => new TomlValue(TomlItemType.Boolean, b));
var hyphen = Chars.Satisfy('-');
var colon = Chars.Satisfy(':');
var twoDigits = digit.Repeat(2);
var datetime = digit.Repeat(4) // year
.Append(hyphen).Append(twoDigits) // month
.Append(hyphen).Append(twoDigits) // day
.Append(
Chars.Sequence("T").Append(twoDigits) // hour
.Append(colon).Append(twoDigits) // minute
.Append(colon).Append(twoDigits) // second
.Append(
Chars.Sequence(".").Append(digits).Optional()
)
.Append(
Chars.Sequence("Z")
.Or(
Chars.Sequence("+").Or(Chars.Sequence("-"))
.Append(twoDigits)
.Append(Chars.Satisfy(':'))
.Append(twoDigits)
)
.Optional()
)
.Optional()
)
.Select(x => new TomlValue(TomlItemType.Datetime, XmlConvert.ToDateTimeOffset(string.Concat(x))));
Parser <char, TomlValue> arrayRef = null;
var array = Delayed.Return(() => arrayRef);
Parser <char, TomlValue> inlineTableRef = null;
var inlineTable = Delayed.Return(() => inlineTableRef);
var key = Chars.Satisfy(c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-')
.Many1().Or(basicString.Select(x => (string)x.Value));
var value = Combinator.Choice(
multilineBasicString, basicString, multilineLiteralString, literalString, // 順番大事
datetime, floatv, integer, boolv, Combinator.Lazy(array), Combinator.Lazy(inlineTable)
);
inlineTableRef = key.Between(spaces, spaces)
.Pipe(
Chars.Satisfy('=').Bindr(value.Between(spaces, spaces)),
(k, v) => new KeyValue(k, v, null)
)
.SepEndBy0(Chars.Satisfy(',').Ignore())
.Between(Chars.Satisfy('{').Ignore(), spaces.SeqIgnore(Chars.Satisfy('}')))
.Select(x => new TomlValue(TomlItemType.InlineTable, x));
var comments = comment.Between(spacesOrNewlines, spacesOrNewlines).Many0();
var comma = Chars.Satisfy(',').Between(spacesOrNewlines, spacesOrNewlines).Ignore();
Func <Parser <char, TomlValue>, Parser <char, TomlValue> > createArrayParser = p =>
Chars.Satisfy('[').Bindr(
from i in
(from b in comments
from v in p.Between(spacesOrNewlines, spacesOrNewlines)
from a in comments
select new ArrayItem(v, b, a)
).SepEndBy0(comma)
from c in comments.Bindl(Chars.Satisfy(']'))
select new TomlValue(TomlItemType.Array, i.Concat(new[] { new ArrayItem(null, null, c) }))
);
arrayRef = Combinator.Choice(
createArrayParser(Combinator.Choice(
multilineBasicString, basicString, multilineLiteralString, literalString)), // 順番大事
createArrayParser(datetime),
createArrayParser(floatv),
createArrayParser(integer),
createArrayParser(boolv),
createArrayParser(Combinator.Lazy(array)),
createArrayParser(Combinator.Lazy(inlineTable))
);
var tableName = key.Between(spaces, spaces).SepBy1(Chars.Satisfy('.').Ignore());
var startTable = tableName.Between(
spacesOrNewlines.SeqIgnore(Chars.Satisfy('[')),
Chars.Satisfy(']').SeqIgnore(spaces)
);
var startTableLine = from t in startTable
from c in newlineOrComment
select new TableInfo(t, c, false);
var startArrayOfTable = tableName.Between(
spacesOrNewlines.SeqIgnore(Chars.Sequence("[[")),
Chars.Sequence("]]").SeqIgnore(spaces)
);
var startArrayOfTableLine = from t in startArrayOfTable
from c in newlineOrComment
select new TableInfo(t, c, true);
var keyValue = from k in key.Between(spacesOrNewlines, spaces)
from v in Chars.Satisfy('=').Bindr(value.Between(spaces, spaces))
from c in newlineOrComment
select(TableNode) new KeyValue(k, v, c);
var nodes = Combinator.Choice(keyValue, spacesOrNewlines.Bindr(comment)).Many0();
var table = from t in Combinator.Choice(startTableLine, startArrayOfTableLine)
from c in nodes
select new Table(t, c);
v04Parser = from r in nodes
from t in table.Many0().Bindl(spacesOrNewlines)
select new ParseResult(r, t);
}
