object Eval(Expression expression, EvalOption option)
{
if (expression is AttributeExpression)
{
return(EvalAttribute(expression as AttributeExpression, option));
}
else if (expression is SubstitutionExpression)
{
EvalSubstitution(expression as SubstitutionExpression, option);
return(null);
}
else if (expression is LabelExpression)
{
return(EvalLabel(expression as LabelExpression, option));
}
else if (expression is NumberExpression)
{
var expr = expression as NumberExpression;
var value = new Value();
var node = new NodeConstantNumber();
node.Expression = expr;
node.Value = expr.Value;
node.Outputs.Add(value);
value.Generator = node;
value.Index = 0;
return(value);
}
else if (expression is FunctionExpression)
{
return(EvalFunction(expression as FunctionExpression, option));
}
else if (expression is BinOpExpression)
{
var expr = expression as BinOpExpression;
var node = new NodeOperator();
node.Expression = expr;
if (expr.Operator == "+")
{
node.Type = OperatorType.Add;
}
if (expr.Operator == "-")
{
node.Type = OperatorType.Sub;
}
if (expr.Operator == "*")
{
node.Type = OperatorType.Mul;
}
if (expr.Operator == "/")
{
node.Type = OperatorType.Div;
}
if (expr.Operator == "%")
{
node.Type = OperatorType.Mod;
}
var lhs = Eval(expr.Lhs, null);
if (lhs is Attribute)
{
lhs = (lhs as Attribute).Value;
}
var rhs = Eval(expr.Rhs, null);
if (rhs is Attribute)
{
rhs = (rhs as Attribute).Value;
}
if (lhs is SymbolTable)
{
var retTable = new SymbolTable();
int ind = 0;
foreach (var table in (lhs as SymbolTable).Tables)
{
var ret = new Value();
ret.Index = ind;
ret.Generator = node;
node.Inputs.Add(table.Value.Value as Value);
if (!(table.Value.Value is Value))
{
throw new InvalidOperationException(expression.Line);
}
if (rhs is Value)
{
node.Inputs.Add(rhs as Value);
}
else if (rhs is SymbolTable)
{
var rhs_ = rhs as SymbolTable;
if (!rhs_.Tables.ContainsKey(table.Key))
{
throw new InvalidOperationException(expression.Line);
}
var value = rhs_.Tables[table.Key].Value as Value;
if (value == null)
{
throw new InvalidOperationException(expression.Line);
}
node.Inputs.Add(value);
}
node.Outputs.Add(ret);
retTable.Tables.Add(table.Key, new Attribute(ret));
ind++;
}
return(retTable);
}
else if (lhs is Value)
{
if (!(rhs is Value))
{
throw new InvalidOperationException(expression.Line);
}
var ret = new Value();
ret.Index = 0;
ret.Generator = node;
node.Inputs.Add(lhs as Value);
node.Inputs.Add(rhs as Value);
node.Outputs.Add(ret);
return(ret);
}
}
else if (expression is UnaryOpExpression)
{
var expr = expression as UnaryOpExpression;
var node = new NodeOperator();
if (expr.Operator == "+")
{
node.Type = OperatorType.UnaryAdd;
}
if (expr.Operator == "-")
{
node.Type = OperatorType.UnarySub;
}
var input = Eval(expr.Expr, null);
if (input is Attribute)
{
input = (input as Attribute).Value;
}
if (input is SymbolTable)
{
var retTable = new SymbolTable();
int ind = 0;
foreach (var table in (input as SymbolTable).Tables)
{
var ret = new Value();
ret.Index = ind;
ret.Generator = node;
if (!(table.Value.Value is Value))
{
throw new InvalidOperationException(expression.Line);
}
node.Inputs.Add(table.Value.Value as Value);
node.Outputs.Add(ret);
retTable.Tables.Add(table.Key, new Attribute(ret));
ind++;
}
return(retTable);
}
else if (input is Value)
{
var ret = new Value();
ret.Index = 0;
ret.Generator = node;
node.Inputs.Add(input as Value);
node.Outputs.Add(ret);
return(ret);
}
}
throw new Exception();
}
object EvalFunction(FunctionExpression expr, EvalOption option)
{
var node = new NodeOperator();
node.Expression = expr;
if (expr.Value == "sin")
{
node.Type = OperatorType.Sine;
}
if (expr.Value == "cos")
{
node.Type = OperatorType.Cos;
}
if (expr.Args.Count() != 1)
{
throw new ArgSizeException(expr.Args.Count(), 1, expr.Line);
}
var input = Eval(expr.Args[0], null);
if (input is Attribute)
{
input = (input as Attribute).Value;
}
if (input is SymbolTable)
{
var retTable = new SymbolTable();
int ind = 0;
foreach (var table in (input as SymbolTable).Tables)
{
var ret = new Value();
ret.Index = ind;
ret.Generator = node;
if (!(table.Value.Value is Value))
{
throw new InvalidOperationException(expr.Line);
}
node.Inputs.Add(table.Value.Value as Value);
node.Outputs.Add(ret);
retTable.Tables.Add(table.Key, new Attribute(ret));
ind++;
}
return(retTable);
}
else if (input is Value)
{
var ret = new Value();
ret.Index = 0;
ret.Generator = node;
node.Inputs.Add(input as Value);
node.Outputs.Add(ret);
return(ret);
}
else
{
throw new Exception();
}
}
public RuleExpression(NodeOperator nodeOperator, List <RuleExpression> expressions, Rule rule)
{
this.NodeOperator = nodeOperator;
this.Expressions = expressions;
this.Rule = rule;
}
public void NodeOperatorConstructorWithRightNodeNullThrows()
{
var _ = new NodeOperator(new NodeNumeric("1"), OperatorType.Add, null);
}
public void NodeOperatorConstructorWithLeftNodeNullThrows()
{
var _ = new NodeOperator(null, OperatorType.Add, new NodeNumeric("1"));
}
public void NodeOperatorEvaluateWithInvalidOperatorTypeThrows()
{
var node = new NodeOperator(new NodeNumeric("1"), (OperatorType)99, new NodeNumeric("1"));
node.Evaluate(null);
}
