private static void SerializeTokenString(XToken token, SerializationContext ctx)
{
var value = (string)token.Data;
ctx.Builder.Append('"' + value + '"');
ctx.LastIsAlphaNum = false;
}
private static void SerializeTokenMatch(XToken token, SerializationContext ctx)
{
var mtk = (XTokenMatchParam)token;
ctx.Builder.Append($"/{mtk.Data}/{mtk.Flags}");
ctx.LastIsAlphaNum = true;
}
private static void SerializeTokenRefId(XToken token, SerializationContext ctx)
{
if (ctx.LastIsAlphaNum)
{
ctx.Builder.Append(' ');
}
ctx.Builder.Append(token.Data);
ctx.LastIsAlphaNum = true;
}
private static void SerializeTokenOperMatch(XToken token, SerializationContext ctx)
{
if (ctx.LastIsAlphaNum)
{
ctx.Builder.Append(' ');
}
ctx.Builder.Append("match");
ctx.LastIsAlphaNum = true;
}
public static XTreeNodeBase Parse(string text)
{
var reader = new Reader(text ?? string.Empty);
Scanner.Scan(reader);
XToken partialTree = Parser.ResolveParensPair(reader.Tokens.GetEnumerator());
return(Parser.BuildTree(partialTree));
}
private static void SerializeTokenBoolean(XToken token, SerializationContext ctx)
{
if (ctx.LastIsAlphaNum)
{
ctx.Builder.Append(' ');
}
var value = (bool)token.Data;
ctx.Builder.Append(value ? "true" : "false");
ctx.LastIsAlphaNum = true;
}
private static void SerializeTokenNumber(XToken token, SerializationContext ctx)
{
if (ctx.LastIsAlphaNum)
{
ctx.Builder.Append(' ');
}
var value = (double)token.Data;
ctx.Builder.Append(value.ToString(CultureInfo.InvariantCulture));
ctx.LastIsAlphaNum = true;
}
internal static XTreeNodeBase BuildTree(XToken token)
{
if (token is XTokenSubTree)
{
var source = token.Data as IReadOnlyList <XToken>;
return(BuildTree(source, 0, source.Count - 1));
}
else if (token.Arity == 0)
{
return(new XTreeNodeTerminal(token));
}
else
{
throw new XParserException($"Unexpected token: {token}");
}
}
private static XTreeNodeBase BuildTree(
IReadOnlyList <XToken> source,
int ixa,
int ixb
)
{
if (ixa > ixb)
{
throw new XParserException("Empty expression.");
}
else if (ixa == ixb)
{
return(BuildTree(source[ixa]));
}
for (int prio = 1; prio < 16; prio++)
{
for (int i = ixa; i <= ixb; i++)
{
XToken token = source[i];
if (token.Prio == prio)
{
switch (token.Arity)
{
case 1:
return(new XTreeNodeUnary(
token,
BuildTree(source, i + 1, ixb)
));
case 2:
return(new XTreeNodeBinary(
token,
BuildTree(source, ixa, i - 1),
BuildTree(source, i + 1, ixb)
));
default:
throw new XParserException($"Invalid operator type: {token}");
}
}
}
}
throw new XParserException("Missing operator.");
}
private static XToken ScanTwins(
Reader reader,
char head,
XToken result
)
{
reader.MoveNext();
char ch;
if (reader.TryPeek(out ch) == false || ch != head)
{
throw new XParserException($"Illegal character found: {ch}");
}
reader.MoveNext();
return(result);
}
internal static XToken ResolveParensPair(IEnumerator <XToken> iter)
{
var list = new List <XToken>();
while (iter.MoveNext())
{
XToken token = iter.Current;
if (token is XTokenLParen)
{
token = ResolveParensPair(iter);
}
else if (token is XTokenRParen)
{
break;
}
list.Add(token);
}
return(new XTokenSubTree(list));
}
internal static void Scan(Reader reader)
{
char ch;
while (reader.TryPeek(out ch))
{
XToken token = null;
switch (ch)
{
case '(':
reader.Tokens.Add(new XTokenLParen());
reader.MoveNext();
break;
case ')':
reader.Tokens.Add(new XTokenRParen());
reader.MoveNext();
break;
case '&': token = ScanTwins(reader, ch, new XTokenOperAnd()); break;
case '|': token = ScanTwins(reader, ch, new XTokenOperOr()); break;
case '!': token = ScanExclamationSign(reader, ch); break;
case '=': token = ScanEqualSign(reader, ch); break;
case '<': token = ScanLessSign(reader, ch); break;
case '>': token = ScanGreaterSign(reader, ch); break;
case '"': token = ScanString(reader, ch); break;
case '\'': token = ScanString(reader, ch); break;
case '/': token = ScanRegex(reader, ch); break;
case '_': token = ScanLiteral(reader, ch); break;
case '-': token = ScanNumber(reader, ch); break;
case '+': token = ScanNumber(reader, ch); break;
default:
if (char.IsWhiteSpace(ch))
{
reader.MoveNext();
}
else if (char.IsDigit(ch))
{
token = ScanNumber(reader, ch);
}
else if (char.IsLetter(ch))
{
token = ScanLiteral(reader, ch);
}
else
{
throw new XParserException($"Illegal character found: {ch}");
}
break;
}
if (token != null)
{
reader.Tokens.Add(token);
}
}
}
private static void SerializeTokenOperNot(XToken token, SerializationContext ctx)
{
ctx.Builder.Append("!");
ctx.LastIsAlphaNum = false;
}
public XTreeNodeTerminal(XToken token) : base(token)
{
}
private static void SerializeTokenOperGreaterOrEqualThan(XToken token, SerializationContext ctx)
{
ctx.Builder.Append(">=");
ctx.LastIsAlphaNum = false;
}
public XTreeNodeUnary(XToken token, XTreeNodeBase child) : base(token)
{
this.Child = child;
}
public XTreeNodeBinary(XToken token, XTreeNodeBase left, XTreeNodeBase right) : base(token)
{
this.LeftChild = left;
this.RightChild = right;
}
protected XTreeNodeBase(XToken token)
{
this.Token = token;
}
