public void SetProperty(string str, ExpressionValue value)
{
this.members.Remove(str);
this.members.Add(str, value);
}
public void Substitute(ExpressionValue value)
{
this.bValue = value.Bool;
this.nValue = value.Number;
this.sValue = value.String;
}
private ExpressionValue ExecuteStatement(Statement statement, Environment env)
{
switch (statement.Type)
{
case StatementType.ASSIGN:
{
this.Assign(statement.Assignment);
return(null);
}
case StatementType.IF_THEN:
{
ExpressionValue value = this.evaluator.Evaluate(statement.ConditionExpression, this.env);
if (value.Bool == true)
{
return(this.ExecuteStatements(statement.Statement1));
}
return(null);
}
case StatementType.IF_THEN_ELSE:
{
ExpressionValue value = this.evaluator.Evaluate(statement.ConditionExpression, this.env);
if (value.Bool == true)
{
return(this.ExecuteStatements(statement.Statement1));
}
else
{
return(this.ExecuteStatements(statement.Statement2));
}
}
case StatementType.WHILE:
{
ExpressionValue value = this.evaluator.Evaluate(statement.ConditionExpression, this.env);
if (value.Bool == true)
{
Statements st = new Statements();
st.AddStatement(statement.Statement1);
st.AddStatement(statement);
return(this.ExecuteStatements(st));
}
return(null);
}
case StatementType.FUNCTION_DECLARATION:
{
this.DeclareFunction(statement.FunctionDeclaration);
return(null);
}
case StatementType.FUNCTION:
{
return(this.ExecuteFunction(statement.Function));
}
case StatementType.RETURN:
{
return(this.evaluator.Evaluate(statement.ReturnValue, this.Environment));
}
}
return(null);
}
public ExpressionValue Evaluate(Expression exp, Environment env)
{
if (exp == null)
{
return(new ExpressionValue(ExpressionValueType.BOOLEAN, false));
}
switch (exp.Type)
{
case (ExpressionType.FUNCTION):
{
return(this.vm.ExecuteFunction(exp));
}
case (ExpressionType.FUNCTION_DECLARATION):
{
return(new ExpressionValue(ExpressionValueType.FUNCTION, exp.Function));
}
case (ExpressionType.OBJECT):
{
return(new ExpressionValue(ExpressionValueType.OBJECT));
}
case (ExpressionType.OBJECT_ACCESSOR):
{
List <string> accessor = exp.AccessKey;
ExpressionValue v = env.Get(accessor [0]) as ExpressionValue;
for (int i = 1; i < accessor.Count; i++)
{
v = v.GetProperty(accessor [i]);
}
return(v);
}
case (ExpressionType.IDENTIFIER):
{
string id = exp.Value;
return(env.Get(id) as ExpressionValue);
}
case (ExpressionType.BOOL):
{
return(exp.EvaluatedValue);
}
case (ExpressionType.STRING):
{
return(exp.EvaluatedValue);
}
case (ExpressionType.INTEGER):
{
return(exp.EvaluatedValue);
}
case (ExpressionType.PLUS):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
if (v1.IsString)
{
return(new ExpressionValue(ExpressionValueType.STRING, v1.String + v2.String));
}
else
{
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number + v2.Number));
}
}
case (ExpressionType.MINUS):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number - v2.Number));
}
case (ExpressionType.TIMES):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number * v2.Number));
}
case (ExpressionType.DIVISION):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number / v2.Number));
}
case (ExpressionType.AND):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Bool && v2.Bool));
}
case (ExpressionType.OR):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Bool || v2.Bool));
}
case (ExpressionType.EQUAL):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN,
(v1.Bool == v2.Bool) && (v1.Number == v2.Number) && (v1.String == v2.String)));
}
case (ExpressionType.DISEQUAL):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN,
(v1.Bool != v2.Bool) && (v1.Number != v2.Number) && (v1.String != v2.String)));
}
case (ExpressionType.LESS):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Number < v2.Number));
}
case (ExpressionType.GREATER):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number > v2.Number));
}
case (ExpressionType.LESS_OR_EQUAL):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number <= v2.Number));
}
case (ExpressionType.GREATER_OR_EQUAL):
{
ExpressionValue v1 = this.Evaluate(exp.Expression1, env);
ExpressionValue v2 = this.Evaluate(exp.Expression2, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number >= v2.Number));
}
default:
return(null);
}
}
private ExpressionValue ExecuteSystemFunction(Expression fun)
{
// Print function
if (fun.FunctionName == "print")
{
ExpressionValue val = this.evaluator.Evaluate(fun.Parameters [0], this.env);
if (val.IsNumber)
{
if (float.IsInfinity(val.Number))
{
Console.WriteLine("Infinity");
}
else if (float.IsNaN(val.Number))
{
Console.WriteLine("NaN");
}
else
{
Console.WriteLine(val.Number);
}
}
else if (val.IsBool)
{
Console.WriteLine(val.Bool);
}
else if (val.IsString)
{
Console.WriteLine(val.String);
}
else if (val.IsFunction)
{
Console.WriteLine("Function " + val.Function.Identifier);
}
else if (val.IsObject)
{
Console.WriteLine("Object");
}
else
{
Console.WriteLine("undefined");
}
return(null);
// Require function
}
else if (fun.FunctionName == "require")
{
if (fun.Parameters.Count != 1)
{
return(null);
}
ExpressionValue fileName = this.evaluator.Evaluate(fun.Parameters [0], this.env);
if (!fileName.IsString)
{
return(null);
}
Interpreter i = Interpreter.FromFile(fileName.String);
i.Init();
ExpressionValue v = i.RunAsModule();
return(v);
}
else
{
return(null);
}
}
