public override double Eval(IContext ctx)
{
var rhsVal = _rhs.Eval(ctx);
var result = _op(rhsVal);
return(result);
}
public override Object Eval()
{
Object var = varNode.Eval();
int index = ((int)keyNode.Eval());
Object ret = ((List <Object>)var)[index];
return(ret);
}
public override Object Eval()
{
Object ret = null;
while ((bool)condition.Eval())
{
ret = body.Eval();
}
return(ret);
}
public override Object Eval()
{
if (value is Function)
{
return(parser.setVariable(name, value));
}
else
{
return(parser.setVariable(name, value.Eval()));
}
}
public override Object Eval()
{
Object ret = null;
if ((condition != null) && (thenPart != null))
{
if ((bool)condition.Eval())
{
ret = thenPart.Eval();
}
}
if ((condition != null) && (elsePart != null))
{
if (!(Boolean)condition.Eval())
{
ret = elsePart.Eval();
}
}
return(ret);
}
public override Object Eval()
{
Object arrayVariable = array.Eval();
double index = ToDouble(indexExpression);
int intIndex = Int32.Parse(index.ToString());
Object newValue = rightSideExpression.Eval();
((List <Object>)arrayVariable)[intIndex] = newValue;
Object ret = arrayVariable;
return(ret);
}
public override Object Eval()
{
Object res = null;
variable.Eval();
while ((bool)condition.Eval())
{
res = body.Eval();
action.Eval();
}
return(res);
}
public override Object Eval()
{
int waitAmount = (int)interval.Eval();
try
{
System.Threading.Thread.Sleep(waitAmount);
}
catch (Exception e)
{
Console.WriteLine("Error in WaitNode.eval() method" + e);
}
return(waitAmount);
}
public override Object Eval()
{
Object writee = expression.Eval();
if (type.Equals("sameline"))
{
Console.WriteLine(writee);
}
else
if (type.Equals("newline"))
{
Console.WriteLine(writee);
}
return(writee);
}
public override Object Eval()
{
// Get the function object from symbol table
// with this name by evaluating variable node
Function function = (Function)name.Eval();
List <BoundParameter> boundParameters = new List <BoundParameter>();
if (function.getParameters() != null)
{
// Some functions do not have parameters, check it out
if (actualParameters != null)
{
if (actualParameters.Count() < function.getParameters().Count())
{
Console.WriteLine("Too Few Parameters in Function Call: "
+ function.getName());
Environment.Exit(0);
}
else if (actualParameters.Count > function.getParameters().Count)
{
Console.WriteLine("Too Many Parameters in Function Call: " + function.getName());
Environment.Exit(0);
}
else
{
// Bind actual parameters
for (int index = 0; index < actualParameters.Count; index++)
{
String name = function.getParameters()[index].getName();
Object value = actualParameters[index].getValue();
//If the parameter is a function!
if (value is Function)
{
value = ((Function)value).Eval();
}
boundParameters.Add(new BoundParameter(name, value));
}
}
}
}
//Now, call this function
return(parser.ExecuteFunction(function, boundParameters));
}
public void Interpret(String source, bool debug)
{
Tokenizer tokenizer = new Tokenizer();
Parser parser = new Parser(tokenizer.Tokenize(source));
parser.setVariable("pi", 3.14159265358979);
parser.setVariable("e", 2.718281828459045);
if (debug)
{
DumpTokens(parser);
}
parser.MatchAndEat(TokenType.SCRIPT);
Console.WriteLine("\n=============== Building block! =================\n");
Node script = parser.Block();
script.Eval();
}
public double ToDouble(Node node)
{
Object res = node.Eval();
return(Double.Parse(res.ToString()));
}
public Object Eval()
{
return(value.Eval());
}
public override Object Eval()
{
return(body.Eval());
}
public bool ToBoolean(Node node)
{
Object res = node.Eval();
return((bool)res);
}
public Object ToObject(Node node)
{
return(node.Eval());
}
