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.kind)
{
case StatementType.ASSIGN:
{
AssignmentStatement asg = statement as AssignmentStatement;
this.Assign(asg.assignment);
return(null);
}
case StatementType.IF:
{
IfStatement st = statement as IfStatement;
ExpressionValue value = this.evaluator.Evaluate(st.condition.Expression, this.env);
if (value.Bool == true)
{
return(this.ExecuteStatements(st.body));
}
return(null);
}
case StatementType.IF_ELSE:
{
IfElseStatement st = statement as IfElseStatement;
ExpressionValue value = this.evaluator.Evaluate(st.condition.Expression, this.env);
if (value.Bool == true)
{
return(this.ExecuteStatements(st.ifBody));
}
else
{
return(this.ExecuteStatements(st.elseBody));
}
}
case StatementType.WHILE:
{
WhileStatement st = statement as WhileStatement;
ExpressionValue value = this.evaluator.Evaluate(st.condition.Expression, this.env);
if (value.Bool == true)
{
Statements ss = new Statements();
ss.AddStatement(st.body);
ss.AddStatement(st);
return(this.ExecuteStatements(ss));
}
return(null);
}
case StatementType.FUNC_DECL:
{
FunctionStatement st = statement as FunctionStatement;
this.DeclareFunction(st.function);
return(null);
}
case StatementType.FUNCTION:
{
FunctionStatement st = statement as FunctionStatement;
return(this.ExecuteFunction(st.val));
}
case StatementType.RETURN:
{
FunctionStatement st = statement as FunctionStatement;
return(this.evaluator.Evaluate(st.val, this.Environment));
}
}
return(null);
}
public ExpressionValue Evaluate(Expression exp, Environment env)
{
if (exp == null)
{
return(new ExpressionValue(ExpressionValueType.BOOLEAN, false));
}
switch (exp.kind)
{
case (ExpressionType.FUNCTION):
{
FunctionExpression ex = exp as FunctionExpression;
return(this.vm.ExecuteFunction(ex));
}
case (ExpressionType.FUNCT_DECL):
{
FunctionExpression decl = exp as FunctionExpression;
return(new ExpressionValue(ExpressionValueType.FUNCTION, decl.function));
}
case (ExpressionType.OBJECT):
{
return(new ExpressionValue(ExpressionValueType.OBJECT));
}
case (ExpressionType.GET_OBJ):
{
AccessKeyExpression get = exp as AccessKeyExpression;
List <string> accessor = get.AccessObj;
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):
{
TokenExpression tok = exp as TokenExpression;
string id = tok.token.Value;
return(env.Get(id) as ExpressionValue);
}
case (ExpressionType.BOOL):
{
return(exp.value);
}
case (ExpressionType.STRING):
{
return(exp.value);
}
case (ExpressionType.INTEGER):
{
return(exp.value);
}
case (ExpressionType.ADD):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
if (v1.IsString)
{
return(new ExpressionValue(ExpressionValueType.STRING, v2.String + v1.String));
}
else
{
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number + v2.Number));
}
}
case (ExpressionType.SUBS):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number - v2.Number));
}
case (ExpressionType.MUL):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number * v2.Number));
}
case (ExpressionType.DIV):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number / v2.Number));
}
case (ExpressionType.AND):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Bool && v2.Bool));
}
case (ExpressionType.OR):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Bool || v2.Bool));
}
case (ExpressionType.EQUAL):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN,
(v1.Bool == v2.Bool) && (v1.Number == v2.Number) && (v1.String == v2.String)));
}
case (ExpressionType.DISEQUAL):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN,
(v1.Bool != v2.Bool) && (v1.Number != v2.Number) && (v1.String != v2.String)));
}
case (ExpressionType.LESS):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.BOOLEAN, v1.Number < v2.Number));
}
case (ExpressionType.GREATER):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number > v2.Number));
}
case (ExpressionType.LESS_OR_EQUAL):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number <= v2.Number));
}
case (ExpressionType.GREATER_OR_EQUAL):
{
OperationExpression op = exp as OperationExpression;
ExpressionValue v1 = this.Evaluate(op.lhs, env);
ExpressionValue v2 = this.Evaluate(op.rhs, env);
return(new ExpressionValue(ExpressionValueType.NUMBER, v1.Number >= v2.Number));
}
default:
return(null);
}
}
private ExpressionValue ExecuteSystemFunction(Expression _fun)
{
FunctionExpression fun = _fun as FunctionExpression;
if (fun.name == "print")
{
string str = "";
ExpressionValue val = this.evaluator.Evaluate(fun.parameters[0], this.env);
if (val.IsNumber)
{
if (float.IsInfinity(val.Number))
{
str = "Infinity";
}
else if (float.IsNaN(val.Number))
{
str = "NaN";
}
else
{
str = val.Number.ToString();
}
}
else if (val.IsBool)
{
str = val.Bool.ToString();
}
else if (val.IsString)
{
str = val.String;
}
else if (val.IsFunction)
{
str = ("Function " + val.Function.Identifier);
}
else if (val.IsObject)
{
str = "Object";
}
else
{
str = "Undefined";
}
if (fun.parameters.Count < 5 || fun.parameters.Count > 1)
{
List <string> vals = new List <string>();
for (int i = 1; i < fun.parameters.Count; i++)
{
ExpressionValue exp = this.evaluator.Evaluate(fun.parameters[i], this.env);
switch (i)
{
case 1: // font size
if (exp.IsNumber)
{
vals.Add(exp.Number.ToString());
}
break;
case 2: // color
if (exp.IsString)
{
vals.Add(exp.String);
}
break;
case 3: // top
if (exp.IsNumber)
{
vals.Add(exp.Number.ToString());
}
break;
case 4: // left
if (exp.IsNumber)
{
vals.Add(exp.Number.ToString());
}
break;
case 5: // font
if (exp.IsString)
{
vals.Add(exp.String);
}
break;
default:
break;
}
}
OutputFormatter op = new OutputFormatter(vals.ToArray(), str);
Console.WriteLine(op.ToString());
}
else
{
Console.WriteLine(OutputFormatter.GetOnlyTag(str));
}
return(null);
}
else if (fun.name == "import")
{
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);
}
}
