public override StringBuilder AppendTo(StringBuilder sb)
{
sb.Append("(ERROR ");
sb = StringExpr.Format(Message, sb);
sb.Append(')');
return(sb);
}
static void Output(object result)
{
object[] results;
if (result == null)
{
Console.Write("null");
}
else if (result is string)
{
var quotedStr = StringExpr.Format((string)result).ToString();
Console.Write(quotedStr);
}
else if ((results = result as object[]) != null)
{
Console.Write('[');
for (int i = 0; i < results.Length; ++i)
{
Output(results[i]);
if (i < results.Length - 1)
{
Console.Write(' ');
}
}
Console.Write(']');
}
else if (result is bool)
{
if ((bool)result)
{
Console.Write("true");
}
else
{
Console.Write("false");
}
}
else if (result is SExpr)
{
var sexpr = (SExpr)result;
var sb = new StringBuilder();
sb = sexpr.AppendTo(sb);
Console.Write(sb.ToString());
}
else
{
Console.Write(result.ToString());
}
}
public SExpr ParseExpr()
{
Next();
if (next.IsRight)
{
return(next.Right);
}
if (tok.Type == TokenType.ParenOpen)
{
var start = tok;
// NOTE(jsd): Built-in identifier expression parser here. Probably should extract this for general purpose usage.
// Expect function name:
ExpectOr(TokenType.Identifier, TokenType.Dot);
if (next.IsRight)
{
return(next.Right);
}
var identStart = tok;
IdentifierExpr ident;
// "memberName"
// ".memberName"
// "namespace.Type/memberName"
if (next.Left.Type == TokenType.Dot)
{
// ".memberName":
Expect(TokenType.Identifier);
if (next.IsRight)
{
return(next.Right);
}
ident = new InstanceMemberIdentifierExpr(identStart, next.Left);
Next();
if (next.IsRight)
{
return(next.Right);
}
}
else
{
// "memberName"
var typeNameParts = new List <Token>(5);
typeNameParts.Add(next.Left);
// "namespace.typeName" ?
Next();
while (!next.IsRight && next.Left.Type == TokenType.Dot)
{
Next();
if (next.Left.Type == TokenType.Slash)
{
break;
}
if (next.Left.Type != TokenType.Identifier)
{
break;
}
typeNameParts.Add(next.Left);
Next();
}
;
if (next.IsRight)
{
return(next.Right);
}
// Determine what type of identifier:
if (next.Left.Type == TokenType.Slash)
{
// "namespace.typeName/memberName"
Expect(TokenType.Identifier);
if (next.IsRight)
{
return(next.Right);
}
ident = new StaticMemberIdentifierExpr(typeNameParts.ToArray(), next.Left);
Next();
if (next.IsRight)
{
return(next.Right);
}
}
else
{
if (typeNameParts.Count != 1)
{
return(new ParserError(tok, "Scoped identifier expression must have only one identifier part"));
}
ident = new ScopedIdentifierExpr(typeNameParts[0]);
}
}
// Parse parameters:
List <SExpr> parameters;
if (tok.Type == TokenType.ParenClose)
{
// No parameters:
parameters = new List <SExpr>(0);
}
else
{
// At least one parameter:
parameters = new List <SExpr>();
do
{
Hold();
var expr = ParseExpr();
Debug.Assert(expr != null);
if (expr.Kind == SExprKind.Error)
{
return(expr);
}
parameters.Add(expr);
Next();
} while (tok.Type != TokenType.ParenClose);
}
var end = tok;
return(new InvocationExpr(start, end, ident, parameters.ToArray()));
}
else if (tok.Type == TokenType.BracketOpen)
{
var start = tok;
// Parse items:
List <SExpr> items;
Next();
if (next.IsRight)
{
return(next.Right);
}
if (tok.Type == TokenType.BracketClose)
{
// No items:
items = new List <SExpr>(0);
}
else
{
// At least one item:
items = new List <SExpr>();
do
{
Hold();
var expr = ParseExpr();
Debug.Assert(expr != null);
if (expr.Kind == SExprKind.Error)
{
return(expr);
}
items.Add(expr);
Next();
} while (tok.Type != TokenType.BracketClose);
}
var end = tok;
return(new ListExpr(start, end, items.ToArray()));
}
else if (tok.Type == TokenType.Quote)
{
var start = tok;
var expr = ParseExpr();
if (expr.Kind == SExprKind.Error)
{
return(expr);
}
var end = tok;
return(new QuoteExpr(start, end, expr));
}
else if (tok.Type == TokenType.Identifier)
{
var expr = new ScopedIdentifierExpr(tok);
return(expr);
}
else if (tok.Type == TokenType.Integer)
{
long val;
if (!Int64.TryParse(tok.Text, out val))
{
return(new ParserError(tok, "Could not parse '{0}' as an Int64".F(tok.Text)));
}
var expr = new IntegerExpr(tok, val);
return(expr);
}
else if (tok.Type == TokenType.String)
{
var expr = new StringExpr(tok);
return(expr);
}
else if (tok.Type == TokenType.Boolean)
{
bool val;
if (!Boolean.TryParse(tok.Text, out val))
{
return(new ParserError(tok, "Could not parse '{0}' as a boolean".F(tok.Text)));
}
var expr = new BooleanExpr(tok, val);
return(expr);
}
else if (tok.Type == TokenType.Null)
{
var expr = new NullExpr(tok);
return(expr);
}
else if (tok.Type == TokenType.Decimal)
{
decimal val;
if (!Decimal.TryParse(tok.Text, out val))
{
return(new ParserError(tok, "Could not parse '{0}' as a decimal".F(tok.Text)));
}
var expr = new DecimalExpr(tok, val);
return(expr);
}
else if (tok.Type == TokenType.Double)
{
double val;
if (!Double.TryParse(tok.Text, out val))
{
return(new ParserError(tok, "Could not parse '{0}' as a double".F(tok.Text)));
}
var expr = new DoubleExpr(tok, val);
return(expr);
}
else if (tok.Type == TokenType.Float)
{
float val;
if (!Single.TryParse(tok.Text, out val))
{
return(new ParserError(tok, "Could not parse '{0}' as a float".F(tok.Text)));
}
var expr = new FloatExpr(tok, val);
return(expr);
}
return(new ParserError(tok, "Unexpected token '{0}'".F(tok.Type)));
}
public SExpr ParseExpr()
{
Next();
if (next.IsRight) return next.Right;
if (tok.Type == TokenType.ParenOpen)
{
var start = tok;
// NOTE(jsd): Built-in identifier expression parser here. Probably should extract this for general purpose usage.
// Expect function name:
ExpectOr(TokenType.Identifier, TokenType.Dot);
if (next.IsRight) return next.Right;
var identStart = tok;
IdentifierExpr ident;
// "memberName"
// ".memberName"
// "namespace.Type/memberName"
if (next.Left.Type == TokenType.Dot)
{
// ".memberName":
Expect(TokenType.Identifier);
if (next.IsRight) return next.Right;
ident = new InstanceMemberIdentifierExpr(identStart, next.Left);
Next();
if (next.IsRight) return next.Right;
}
else
{
// "memberName"
var typeNameParts = new List<Token>(5);
typeNameParts.Add(next.Left);
// "namespace.typeName" ?
Next();
while (!next.IsRight && next.Left.Type == TokenType.Dot)
{
Next();
if (next.Left.Type == TokenType.Slash)
break;
if (next.Left.Type != TokenType.Identifier)
break;
typeNameParts.Add(next.Left);
Next();
};
if (next.IsRight) return next.Right;
// Determine what type of identifier:
if (next.Left.Type == TokenType.Slash)
{
// "namespace.typeName/memberName"
Expect(TokenType.Identifier);
if (next.IsRight) return next.Right;
ident = new StaticMemberIdentifierExpr(typeNameParts.ToArray(), next.Left);
Next();
if (next.IsRight) return next.Right;
}
else
{
if (typeNameParts.Count != 1)
return new ParserError(tok, "Scoped identifier expression must have only one identifier part");
ident = new ScopedIdentifierExpr(typeNameParts[0]);
}
}
// Parse parameters:
List<SExpr> parameters;
if (tok.Type == TokenType.ParenClose)
{
// No parameters:
parameters = new List<SExpr>(0);
}
else
{
// At least one parameter:
parameters = new List<SExpr>();
do
{
Hold();
var expr = ParseExpr();
Debug.Assert(expr != null);
if (expr.Kind == SExprKind.Error) return expr;
parameters.Add(expr);
Next();
} while (tok.Type != TokenType.ParenClose);
}
var end = tok;
return new InvocationExpr(start, end, ident, parameters.ToArray());
}
else if (tok.Type == TokenType.BracketOpen)
{
var start = tok;
// Parse items:
List<SExpr> items;
Next();
if (next.IsRight) return next.Right;
if (tok.Type == TokenType.BracketClose)
{
// No items:
items = new List<SExpr>(0);
}
else
{
// At least one item:
items = new List<SExpr>();
do
{
Hold();
var expr = ParseExpr();
Debug.Assert(expr != null);
if (expr.Kind == SExprKind.Error) return expr;
items.Add(expr);
Next();
} while (tok.Type != TokenType.BracketClose);
}
var end = tok;
return new ListExpr(start, end, items.ToArray());
}
else if (tok.Type == TokenType.Quote)
{
var start = tok;
var expr = ParseExpr();
if (expr.Kind == SExprKind.Error) return expr;
var end = tok;
return new QuoteExpr(start, end, expr);
}
else if (tok.Type == TokenType.Identifier)
{
var expr = new ScopedIdentifierExpr(tok);
return expr;
}
else if (tok.Type == TokenType.Integer)
{
long val;
if (!Int64.TryParse(tok.Text, out val))
return new ParserError(tok, "Could not parse '{0}' as an Int64".F(tok.Text));
var expr = new IntegerExpr(tok, val);
return expr;
}
else if (tok.Type == TokenType.String)
{
var expr = new StringExpr(tok);
return expr;
}
else if (tok.Type == TokenType.Boolean)
{
bool val;
if (!Boolean.TryParse(tok.Text, out val))
return new ParserError(tok, "Could not parse '{0}' as a boolean".F(tok.Text));
var expr = new BooleanExpr(tok, val);
return expr;
}
else if (tok.Type == TokenType.Null)
{
var expr = new NullExpr(tok);
return expr;
}
else if (tok.Type == TokenType.Decimal)
{
decimal val;
if (!Decimal.TryParse(tok.Text, out val))
return new ParserError(tok, "Could not parse '{0}' as a decimal".F(tok.Text));
var expr = new DecimalExpr(tok, val);
return expr;
}
else if (tok.Type == TokenType.Double)
{
double val;
if (!Double.TryParse(tok.Text, out val))
return new ParserError(tok, "Could not parse '{0}' as a double".F(tok.Text));
var expr = new DoubleExpr(tok, val);
return expr;
}
else if (tok.Type == TokenType.Float)
{
float val;
if (!Single.TryParse(tok.Text, out val))
return new ParserError(tok, "Could not parse '{0}' as a float".F(tok.Text));
var expr = new FloatExpr(tok, val);
return expr;
}
return new ParserError(tok, "Unexpected token '{0}'".F(tok.Type));
}