public static bool TryParse(string str, out Datum d)
{
ICharParser <Datum> parser = Parser.ParseConvert
(
Parser.ParseSequence
(
Parser.ParseDatumWithBoxes.ResultToObject(),
Parser.ParseEOF.ResultToObject()
),
list => (Datum)(list[0]),
"failure message"
);
CharParserContext context = new CharParserContext(str);
ParseResult <Datum> result = context.TryParseAt(parser, 0, str.Length);
if (result is ParseSuccess <Datum> )
{
ParseSuccess <Datum> success = (ParseSuccess <Datum>)result;
d = success.Value;
return(true);
}
d = null;
return(false);
}
private static ICharParser <Datum> BuildParseDatum()
{
ICharParser <Datum> parseDatum = GetParseVariable <Datum>();
ICharParser <Datum> p0 = ParseAlternatives
(
ParseNull,
ParseFalse,
ParseTrue,
ParseConvert(ParseString, s => (Datum)(new StringDatum(s)), null),
ParseConvert(ParseBigRational, r => (Datum)(new RationalDatum(r)), null),
ParseConvert(ParseBigInteger, b => (Datum)(new IntDatum(b)), null),
ParseConvert(ParseDouble, d => (Datum)(new FloatDatum(d)), null),
ParseConvert(ParseSymbol, s => (Datum)(new SymbolDatum(s)), null),
ParseConvert(ParseChar, c => (Datum)(new CharDatum(c)), null),
ParseConvert(ParseGuid, g => (Datum)(new GuidDatum(g)), null),
ParseConvert(ParseByteArray, b => (Datum)(new ByteArrayDatum(b)), null),
BuildQuoteLikeParser(parseDatum, "'", "quote"),
BuildQuoteLikeParser(parseDatum, "`", "quasiquote"),
BuildQuoteLikeParser(parseDatum, ",@", "unquote-splicing"),
BuildQuoteLikeParser(parseDatum, ",", "unquote"),
ParseConvert(BuildListParser(parseDatum), lst => (Datum)(new ListDatum(lst)), null),
ParseConvert(BuildSetParser(parseDatum, SetDatum.Empty, (s, i) => s.Add(i)), s => (Datum)s, null),
ParseConvert(BuildDictionaryParser(parseDatum, parseDatum, DictionaryDatum.Empty, (d, k, v) => d.Add(k, v)), dict => (Datum)dict, null)
)
.WithOptionalLeadingWhiteSpace();
SetParseVariable(parseDatum, p0);
return(p0);
}
public ParseDatumTests()
{
parseNull = Parser.ParseNull;
parseDatum = Parser.ParseDatum;
formatBoolResult = Utility.GetParseResultStringConverter <bool>(b => b.ToString());
formatBigIntegerResult = Utility.GetParseResultStringConverter <BigInteger>(b => b.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
formatDoubleResult = Utility.GetParseResultStringConverter <double>(d => d.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
public ParseOptionalWsTest()
{
ws = Parser.ParseOptionalWhiteSpace;
a = Parser.ParseExact("a", StringComparison.InvariantCultureIgnoreCase).WithOptionalLeadingWhiteSpace();
toString = Utility.GetParseResultStringConverter <Nothing>(n => "null");
toString2 = Utility.GetParseResultStringConverter <string>(s => s.Quoted());
}
public ParseOptRepTests()
{
parserOpt = Parser.ParseOptRep(Parser.ParseExact("abc", StringComparison.InvariantCultureIgnoreCase), true, false);
parserRep = Parser.ParseOptRep(Parser.ParseExact("abc", StringComparison.InvariantCultureIgnoreCase), false, true);
parserOptRep = Parser.ParseOptRep(Parser.ParseExact("abc", StringComparison.InvariantCultureIgnoreCase), true, true);
var listToString = Utility.GetImmutableListStringConverter <string>(i => i.Quoted());
toString = Utility.GetParseResultStringConverter(listToString);
}
private static ICharParser <IDatumBuilder> Atom(this ICharParser <Datum> p)
{
return(ParseConvert
(
p,
dat => (IDatumBuilder)(new AtomBuilder(dat)),
null
));
}
public static ICharParser <ImmutableList <T> > ParseOptRep <T>(ICharParser <T> subParser, bool optional, bool repeating)
{
if (!optional && !repeating)
{
return(ParseConvert(subParser, result => ImmutableList <T> .Empty.Add(result), null));
}
else
{
return(new CharParserOptRep <T>(subParser, optional, repeating));
}
}
public static void SetParseVariable <T>(ICharParser <T> target, ICharParser <T> subParser)
{
if (target is CharParserVariable <T> )
{
var target2 = (CharParserVariable <T>)target;
target2.SubParser = subParser;
}
else
{
throw new ArgumentException($"{nameof(target)} is not a parse variable");
}
}
public static ICharParser <ImmutableList <T> > BuildListParser <T>(ICharParser <T> itemParser)
{
return(ParseConvert
(
ParseSequence
(
Token("("),
ParseOptRep(itemParser.WithOptionalLeadingWhiteSpace(), true, true).ResultToObject(),
Token(")")
),
objs => (ImmutableList <T>)(objs[1]),
null
));
}
public CharParserOptRep(ICharParser <T> subParser, bool optional, bool repeating)
{
if (subParser == null)
{
throw new ArgumentNullException(nameof(subParser));
}
this.subParser = subParser;
this.optional = optional;
this.repeating = repeating;
if (!optional && !repeating)
{
throw new ArgumentException("CharParserOptRep must be optional or repeating or both");
}
}
private static ICharParser <IDatumBuilder> BuildQuoteLikeParser(ICharParser <IDatumBuilder> item, string token, string quoteSymbolName)
{
return(ParseConvert
(
ParseSequence
(
Token(token),
ParseConvert(item, d => (object)d, null)
),
list =>
{
return (IDatumBuilder)(new ListBuilder(ImmutableList <IDatumBuilder> .Empty.Add(new AtomBuilder(new SymbolDatum(quoteSymbolName))).Add((IDatumBuilder)list[1])));
},
"Failed to convert " + quoteSymbolName
));
}
public ParseResult <V> TryParseAt <V>(ICharParser <V> parser, int pos, int len)
{
long parserId = idgen.GetId(parser);
PosLenId posLenId = new PosLenId(pos, len, parserId);
if (memoTable.ContainsKey(posLenId))
{
return((ParseResult <V>)memoTable[posLenId]);
}
else
{
ParseResult <V> r = parser.TryParse(this, pos, len);
memoTable = memoTable.SetItem(posLenId, r);
return(r);
}
}
public static ICharParser <Datum> BuildQuoteLikeParser(ICharParser <Datum> item, string token, string quoteSymbolName)
{
return(ParseConvert
(
ParseSequence
(
Token(token),
ParseConvert(item, d => (object)d, null)
),
list =>
{
return (Datum)(new ListDatum(ImmutableList <Datum> .Empty.Add(new SymbolDatum(quoteSymbolName)).Add((Datum)list[1])));
},
"Failed to convert " + quoteSymbolName
));
}
private static ICharParser <T> WithOptionalLeadingWhiteSpace_Internal <T>(this ICharParser <T> parser)
{
return(ParseConvert
(
ParseSequence
(
ParseConvert
(
ParseOptionalWhiteSpace,
_ => default(T),
null
),
parser
),
lst => lst[1],
null
));
}
public static ICharParser <T> WithOptionalLeadingWhiteSpace <T>(this ICharParser <T> parser)
{
lock (olwsSyncRoot)
{
object result;
bool hasResult = olwsDict.TryGetValue(parser, out result);
if (hasResult)
{
return((ICharParser <T>)result);
}
else
{
result = WithOptionalLeadingWhiteSpace_Internal <T>(parser);
olwsDict.Add(parser, result);
olwsDict.Add(result, result);
return((ICharParser <T>)result);
}
}
}
public static ICharParser <TSet> BuildSetParser <TItem, TSet>
(
ICharParser <TItem> itemParser,
TSet empty,
Func <TSet, TItem, TSet> addItem
)
{
var set = ParseSequence
(
new ICharParser <object>[]
{
Token("#s{"),
ParseOptRep
(
itemParser, true, true
).ResultToObject(),
Token("}")
}
.ToImmutableList()
);
return(ParseConvert
(
set,
objs =>
{
ImmutableList <TItem> items = (ImmutableList <TItem>)objs[1];
TSet s = empty;
foreach (TItem item in items)
{
s = addItem(s, item);
}
return s;
},
null
));
}
public static ICharParser <object> ResultToObject <T>(this ICharParser <T> parser)
{
return(ParseConvert(parser, x => (object)x, null));
}
public static ICharParser <TOut> ParseConvert <TIn, TOut>(ICharParser <TIn> subParser, Func <TIn, TOut> conversionFunc, string failureMessage)
{
return(new CharParserConvert <TIn, TOut>(subParser, conversionFunc, failureMessage));
}
public ParseExactTests()
{
parser = Parser.ParseExact("abc", StringComparison.InvariantCultureIgnoreCase);
toString = Utility.GetParseResultStringConverter <string>(f => f.Quoted());
}
public static ParseResult <V> TryParse <V>(ICharParser <V> parser, string text)
{
CharParserContext cpc = new CharParserContext(text);
return(cpc.TryParseAt(parser, 0, text.Length));
}
public CharParserConvert(ICharParser <TIn> subParser, Func <TIn, TOut> conversionFunc, string failureMessage)
{
this.subParser = subParser;
this.conversionFunc = conversionFunc;
this.failureMessage = failureMessage;
}
private static ICharParser <IDatumBuilder> BuildParseMutableBox(ICharParser <IDatumBuilder> parseItem)
{
return(ParseConvert <ImmutableList <object>, IDatumBuilder>
(
ParseSequence
(
ParseExact("#b", StringComparison.InvariantCulture).ResultToObject(),
ParseOptRep
(
ParseConvert
(
ParseSequence
(
ParseExact("[", StringComparison.InvariantCulture).ResultToObject(),
ParseOptionalWhiteSpace.ResultToObject(),
ParseBigInteger.ResultToObject(),
ParseOptionalWhiteSpace.ResultToObject(),
ParseExact("]", StringComparison.InvariantCulture).ResultToObject()
),
list => list[2],
null
),
true,
false
)
.ResultToObject(),
ParseOptRep
(
ParseConvert
(
ParseSequence
(
ParseExact("=", StringComparison.InvariantCulture).ResultToObject(),
ParseOptionalWhiteSpace.ResultToObject(),
parseItem.ResultToObject()
),
list => list[2],
null
),
true,
false
)
.ResultToObject()
),
list =>
{
ImmutableList <object> keyList = (ImmutableList <object>)list[1];
ImmutableList <object> valueList = (ImmutableList <object>)list[2];
if (keyList.Count == 1)
{
BigInteger keyBig = (BigInteger)(keyList[0]);
if (keyBig < (BigInteger)int.MinValue || keyBig > (BigInteger)int.MaxValue)
{
throw new FormatException("Mutable box key out of range");
}
int key = (int)keyBig;
if (valueList.Count >= 1)
{
System.Diagnostics.Debug.Assert(valueList.Count == 1);
IDatumBuilder value = (IDatumBuilder)valueList[0];
return new BoxBuilder(key, Option <IDatumBuilder> .Some(value));
}
else
{
return new BoxBuilder(key, Option <IDatumBuilder> .None);
}
}
else
{
if (valueList.Count >= 1)
{
System.Diagnostics.Debug.Assert(valueList.Count == 1);
IDatumBuilder value = (IDatumBuilder)valueList[0];
return new BoxBuilder(null, Option <IDatumBuilder> .Some(value));
}
else
{
throw new FormatException("Mutable box requires key, value, or both to be specified");
}
}
},
null
));
}
public static ICharParser <TDict> BuildDictionaryParser <TKey, TValue, TDict>
(
ICharParser <TKey> keyParser,
ICharParser <TValue> valueParser,
TDict empty,
Func <TDict, TKey, TValue, TDict> addItem
)
{
ICharParser <Tuple <TKey, TValue> > kvp = ParseConvert
(
ParseSequence
(
keyParser.ResultToObject(),
Token("=>"),
valueParser.ResultToObject()
),
objs => new Tuple <TKey, TValue>((TKey)objs[0], (TValue)objs[2]),
null
);
var dict = ParseSequence
(
Token("{"),
ParseOptRep
(
ParseConvert
(
ParseSequence
(
kvp.ResultToObject(),
Token(",")
),
lst => (Tuple <TKey, TValue>)lst[0],
null
),
true,
true
)
.ResultToObject(),
ParseOptRep
(
kvp,
true,
false
)
.ResultToObject(),
Token("}")
);
return(ParseConvert
(
dict,
objs =>
{
ImmutableList <Tuple <TKey, TValue> > l1 = (ImmutableList <Tuple <TKey, TValue> >)objs[1];
ImmutableList <Tuple <TKey, TValue> > l2 = (ImmutableList <Tuple <TKey, TValue> >)objs[2];
TDict v = empty;
foreach (Tuple <TKey, TValue> kvp0 in l1.Concat(l2))
{
v = addItem(v, kvp0.Item1, kvp0.Item2);
}
return v;
},
null
));
}
public static ICharParser <TOut> ParseTryConvert <TIn, TOut>(ICharParser <TIn> subParser, Func <TIn, Option <TOut> > tryConversionFunc, string failureMessage)
{
return(new CharParserTryConvert <TIn, TOut>(subParser, tryConversionFunc, failureMessage));
}
