private object GetValue(Dictionary <ExpNode, object> valueDict, ExpNode node)
{
if (valueDict.ContainsKey(node))
{
return(valueDict[node]);
}
return(null);
}
public void AddChild(ExpNode n)
{
if (ChildList == null)
{
ChildList = new List <ExpNode>();
}
ChildList.Add(n);
}
private void SetValue(Dictionary <ExpNode, object> valueDict, ExpNode node, object value)
{
if (valueDict.ContainsKey(node))
{
valueDict[node] = value;
}
else
{
valueDict.Add(node, value);
}
}
private void CompileExp(ExpNode expNode, List <Instruction> list)
{
if (expNode.ChildList != null)
{
foreach (ExpNode child in expNode.ChildList)
{
CompileExp(child, list);
}
}
Instruction i = MapTokenToInstruction(expNode.Token);
list.Add(i);
}
private List <ExpNode> Process(List <ExpNode> list, ProcessType type)
{
//Parens
TokenType oToken = type == ProcessType.Brackets ? TokenType.Obrack : TokenType.Oparen;
TokenType cToken = type == ProcessType.Brackets ? TokenType.Cbrack : TokenType.Cparen;
var bi = FindInner(list, oToken, cToken);
var innerList = CreateInnerList(list, bi);
if (IsFuncOrList(bi.Item1, list, type))
{
ExpNode node = list[bi.Item1 - 1];
if (type == ProcessType.Parens)
{
node.IsFunction = true;
List <List <ExpNode> > arglist = SplitFuncArguments(innerList);
foreach (List <ExpNode> arg in arglist)
{
List <ExpNode> argResult = BuildTree(arg);
if (argResult.Count > 1)
{
throw new Exception("Function Argument must resolve to a single ExpNode. spiz.");
}
node.AddChild(argResult[0]);
}
}
else
{
node.IsListIndex = true;
List <ExpNode> indexResult = BuildTree(innerList);
if (indexResult.Count > 1)
{
throw new Exception("List Index must resolve to a single ExpNode. spiz.");
}
node.AddChild(indexResult[0]);
}
list.RemoveRange(bi.Item1, bi.Item2 - bi.Item1 + 1);
return(BuildTree(list));
}
else
{
list.RemoveRange(bi.Item1, bi.Item2 - bi.Item1 + 1);
var ls = BuildTree(innerList);
list.InsertRange(bi.Item1, ls);
return(BuildTree(list));
}
}
private int FindIndexOfFirstOp(List <ExpNode> list, List <TokenType> ops)
{
for (int i = 0; i < list.Count; i++)
{
ExpNode node = list[i];
if (node.IsLeaf())
{
foreach (TokenType op in ops)
{
if (node.Token.Type == op)
{
return(i);
}
}
}
}
return(-1);
}
public object Eval(AST ast, ExpNode n, State state, Dictionary <ExpNode, object> valueDict)
{
if (n.Token.Type == TokenType.Const)
{
return(n.Token.Value);
}
object v = GetValue(valueDict, n);
if (v != null)
{
return(v);
}
if (n.IsFunction)
{
List <object> argList = new List <object>();
foreach (ExpNode arg in n.ChildList)
{
object r = Eval(ast, arg, state, valueDict);
SetValue(valueDict, arg, r);
argList.Add(r);
}
v = EvalFunc(ast, n.FunctionName, argList, state);
SetValue(valueDict, n, v);
return(v);
}
else if (n.IsListIndex)
{
//Sanity Check
if (n.ChildList.Count > 1)
{
throw new Exception("List Index can only have 1 child spiz.");
}
object index = Eval(ast, n.ChildList[0], state, valueDict);
index = Sub(state, index);
SetValue(valueDict, n.ChildList[0], index);
var list = (List <object>)state[n.ListName].Value;
v = list[int.Parse(index.ToString())];
return(v);
}
if (n.Token.Type == TokenType.VarName)
{
v = n.Token.Value;
v = Sub(state, v);
return(v);
}
//Sanity check
if (!n.Token.IsOp())
{
throw new Exception("Op Type expected.. spiz.");
}
TokenType op = n.Token.Type;
object lValue = Eval(ast, n.ChildList[0], state, valueDict);
lValue = Sub(state, lValue);
object rValue = Eval(ast, n.ChildList[1], state, valueDict);
rValue = Sub(state, rValue);
switch (op)
{
case TokenType.Plus:
v = ToInt(lValue) + ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Minus:
v = ToInt(lValue) - ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Divide:
v = ToInt(lValue) / ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Multiply:
v = ToInt(lValue) * ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Mod:
v = ToInt(lValue) % ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Equal:
v = ToString(lValue) == ToString(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.NotEq:
v = ToString(lValue) != ToString(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Lessthan:
v = ToInt(lValue) < ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.LessThanEq:
v = ToInt(lValue) <= ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.Morethan:
v = ToInt(lValue) > ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
case TokenType.MoreThanEq:
v = ToInt(lValue) >= ToInt(rValue);
SetValue(valueDict, n, v);
return(v);
default:
throw new NotImplementedException("spiz");
}
}
public Expression(ExpNode expNode)
{
ExpTree = expNode;
}
public Expression(List <Token> exp)
{
Exp = exp;
ExpTree = BuildTree();
}
