public void EvaluateUndefinedVariable()
{
Context context = new Context();
VariableExpression expr = new VariableExpression("foo");
Assert.IsNull(expr.Evaluate(context));
}
public void DefineVariableWithName()
{
Context context = new Context();
VariableExpression expr = new VariableExpression("foo");
Assert.AreEqual("foo", expr.Name);
}
public void EvaluateDefinedVariable()
{
Context context = new Context();
context.SetValue("one", 1);
VariableExpression expr = new VariableExpression("one");
Assert.AreEqual(1, expr.Evaluate(context));
Assert.AreEqual("one", expr.Name);
}
public void DefineVariableWithTypeAndInitialValue()
{
Context context = new Context();
IExpression typeexpr = new VariableExpression("List");
DefineVariableCommand expr = new DefineVariableCommand(typeexpr, "a", new ConstantExpression(1));
Assert.AreEqual(1, expr.Execute(context));
Assert.IsTrue(context.HasVariable("a"));
Assert.AreEqual(1, context.GetValue("a"));
Assert.AreEqual("a", expr.Name);
Assert.AreEqual(typeexpr, expr.TypeExpression);
}
private IExpression ParseStringInterpolation(string text)
{
IList<IExpression> expressions = new List<IExpression>();
while (true)
{
int pos = text.IndexOf('$');
if (pos < 0)
{
if (!string.IsNullOrEmpty(text))
{
IExpression textexpr = new ConstantExpression(text);
expressions.Add(textexpr);
}
break;
}
if (pos == text.Length - 1)
throw new ParserException("Unexpected End of String");
string left = text.Substring(0, pos);
if (!string.IsNullOrEmpty(left))
expressions.Add(new ConstantExpression(left));
if (text[pos + 1] == '{')
{
int pos2 = text.IndexOf('}', pos + 1);
if (pos2 < 0)
throw new ParserException("Unexpected End of String");
string subtext = text.Substring(pos + 2, pos2 - pos - 2);
text = text.Substring(pos2 + 1);
Parser parser = new Parser(subtext);
IExpression newexpr = parser.ParseExpression();
if (parser.ParseExpression() != null)
throw new ParserException("Bad String Interpolation");
expressions.Add(newexpr);
}
else if (char.IsLetter(text[pos + 1]))
{
Parser parser = new Parser(text.Substring(pos + 1));
string name = parser.ParseName();
IExpression varexpr = new VariableExpression(name);
expressions.Add(varexpr);
text = text.Substring(pos + name.Length + 1);
}
else
throw new ParserException("Bad String Interpolation");
}
if (expressions.Count == 1)
return expressions[0];
IExpression expression = expressions[0];
foreach (var expr in expressions.Skip(1))
expression = new ArithmeticBinaryExpression(ArithmeticOperator.Add, expression, expr);
return expression;
}
private IExpression ParseSimpleExpression()
{
Token token = this.NextToken();
if (token == null)
return null;
if (token.Type == TokenType.Separator && (token.Value == "}" || token.Value == ")"))
{
this.PushToken(token);
return null;
}
switch (token.Type)
{
case TokenType.Integer:
return new ConstantExpression(int.Parse(token.Value, CultureInfo.InvariantCulture));
case TokenType.Name:
string name = token.Value;
if (name == "null")
return new ConstantExpression(null);
if (name == "true")
return new ConstantExpression(true);
if (name == "false")
return new ConstantExpression(false);
token = this.NextToken();
if (token != null && token.Type == TokenType.Separator && token.Type == TokenType.Separator && token.Value == "(")
{
return new CallExpression(new VariableExpression(name), this.ParseExpressionList(")"));
}
IExpression expr = new VariableExpression(name);
if (token != null)
this.PushToken(token);
return expr;
case TokenType.String:
if (token.Value.Contains('$'))
return this.ParseStringInterpolation(token.Value);
return new ConstantExpression(token.Value);
case TokenType.Separator:
if (token.Value == "(")
{
var result = this.ParseExpression();
this.ParseToken(")", TokenType.Separator);
return result;
}
if (token.Value == "[")
{
var result = this.ParseExpressionList("]");
return new ArrayExpression(result);
}
break;
}
throw new ParserException(string.Format("Unexpected '{0}'", token.Value));
}
