Files
mono/mcs/class/System.Core/System.Linq.jvm/ExpressionInterpreter.cs
T
Leonid Freydovich 2f2417c33d Add some TARGET_JVM specific code.
svn path=/trunk/mcs/; revision=99132
2008-03-27 15:44:08 +00:00

462 lines
14 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Collections.Specialized;
using System.Linq.Expressions;
namespace System.Linq.jvm
{
class ExpressionInterpreter : ExpressionVisitor
{
LambdaExpression _exp;
object[] _args;
object _value = null;
public object Value
{
get { return _value; }
}
public ExpressionInterpreter(object[] args)
{
_args = args;
}
public void Run(LambdaExpression exp)
{
_exp = exp;
Visit(exp.Body);
}
protected override void Visit(Expression expression)
{
if (expression == null)
{
return;
}
if (expression.NodeType == ExpressionType.Power)
{
VisitBinary((BinaryExpression)expression);
}
else
{
base.Visit(expression);
}
}
private void VisitCoalesce(BinaryExpression binary)
{
Visit(binary.Left);
if (_value == null)
{
Visit(binary.Right);
}
}
private void VisitAndAlso(BinaryExpression binary)
{
object right = null;
object left = null;
Visit(binary.Left);
right = _value;
if (right == null || ((bool)right))
{
Visit(binary.Right);
left = _value;
}
_value = Math.And(right, left);
}
private void VisitOrElse(BinaryExpression binary)
{
object right = null;
object left = null;
Visit(binary.Left);
right = _value;
if (right == null || !((bool)right))
{
Visit(binary.Right);
left = _value;
}
_value = Math.Or(right, left);
}
private void VisitCommonBinary(BinaryExpression binary)
{
try
{
Visit(binary.Left);
object left = _value;
Visit(binary.Right);
object right = _value;
if (binary.Method != null)
{
_value = binary.Method.Invoke(null, new object[] { left, right });
return;
}
TypeCode tc = Type.GetTypeCode(binary.Type);
switch (binary.NodeType)
{
case ExpressionType.ArrayIndex:
_value = ((Array)left).GetValue((int)right);
return;
case ExpressionType.Equal:
_value = left.Equals(right);
return;
case ExpressionType.NotEqual:
_value = !left.Equals(right);
return;
case ExpressionType.LessThan:
_value = (Comparer.Default.Compare(left, right) < 0);
return;
case ExpressionType.LessThanOrEqual:
_value = (Comparer.Default.Compare(left, right) <= 0);
return;
case ExpressionType.GreaterThan:
_value = (Comparer.Default.Compare(left, right) > 0);
return;
case ExpressionType.GreaterThanOrEqual:
_value = (Comparer.Default.Compare(left, right) >= 0);
return;
case ExpressionType.RightShift:
_value = Math.RightShift(left, Convert.ToInt32(right), tc);
return;
case ExpressionType.LeftShift:
_value = Math.LeftShift(left, Convert.ToInt32(right), tc);
return;
default:
_value = Math.Evaluate(left, right, binary.Type, binary.NodeType);
break;
}
}
catch (OverflowException)
{
throw;
}
catch (Exception e)
{
throw new NotImplementedException(
string.Format(
"Interpriter for BinaryExpression with NodeType {0} is not implimented",
binary.NodeType),
e);
}
}
protected override void VisitBinary(BinaryExpression binary)
{
switch (binary.NodeType)
{
case ExpressionType.AndAlso:
VisitAndAlso(binary);
return;
case ExpressionType.OrElse:
VisitOrElse(binary);
return;
case ExpressionType.Coalesce:
VisitCoalesce(binary);
return;
default:
VisitCommonBinary(binary);
break;
}
}
protected override void VisitUnary(UnaryExpression unary)
{
Visit(unary.Operand);
object o = _value;
if (unary.Method != null)
{
_value = unary.Method.Invoke(null, new object[] { o });
return;
}
switch (unary.NodeType)
{
case ExpressionType.TypeAs:
if (!Math.IsType(unary.Type, o))
{
_value = null;
}
return;
case ExpressionType.ArrayLength:
_value = ((Array)o).Length;
return;
case ExpressionType.Negate:
_value = Math.Negete(o, Type.GetTypeCode(unary.Type));
return;
case ExpressionType.NegateChecked:
_value = Math.NegeteChecked(o, Type.GetTypeCode(unary.Type));
return;
case ExpressionType.Not:
_value = ! Convert.ToBoolean(o);
return;
case ExpressionType.UnaryPlus:
_value = o;
return;
case ExpressionType.Convert:
_value = Math.ConvertToTypeUnchecked(o, unary.Type);
return;
case ExpressionType.ConvertChecked:
_value = Math.ConvertToTypeChecked(o, unary.Type);
return;
}
throw new NotImplementedException(
string.Format(
"Interpriter for UnaryExpression with NodeType {0} is not implimented",
unary.NodeType));
}
protected override void VisitNew(NewExpression nex)
{
if (nex.Constructor == null)
{
_value = System.Activator.CreateInstance(nex.Type);
}
else
{
object[] parameters = VisitListExpressions(nex.Arguments);
_value = nex.Constructor.Invoke(parameters);
}
}
protected override void VisitTypeIs(TypeBinaryExpression type)
{
Visit(type.Expression);
_value = Math.IsType(type.TypeOperand, _value);
}
private void VisitMemberInfo(MemberInfo mi)
{
object o = _value;
switch (mi.MemberType)
{
case MemberTypes.Field:
_value = ((FieldInfo)mi).GetValue(o);
return;
case MemberTypes.Property:
_value = ((PropertyInfo)mi).GetValue(o, null);
return;
}
throw new NotImplementedException(
string.Format(
"Interpriter for MemberInfo with MemberType {0} is not implimented",
mi.MemberType));
}
protected override void VisitMemberAccess(MemberExpression member)
{
Visit(member.Expression);
VisitMemberInfo(member.Member);
}
protected override void VisitNewArray(NewArrayExpression newArray)
{
switch (newArray.NodeType)
{
case ExpressionType.NewArrayInit:
VisitNewArrayInit(newArray);
return;
case ExpressionType.NewArrayBounds:
VisitNewArrayBounds(newArray);
return;
}
throw new NotImplementedException(
string.Format(
"Interpriter for VisitNewArray with NodeType {0} is not implimented",
newArray.NodeType));
}
private void VisitNewArrayBounds(NewArrayExpression newArray)
{
int[] lengths = new int[newArray.Expressions.Count];
for (int i = 0; i < lengths.Length; i++)
{
Visit(newArray.Expressions[i]);
lengths[i] = (int)_value;
}
_value = Array.CreateInstance(newArray.Type.GetElementType(), lengths);
}
private void VisitNewArrayInit(NewArrayExpression newArray)
{
Array arr = Array.CreateInstance(
newArray.Type.GetElementType(),
newArray.Expressions.Count);
for (int i = 0; i < arr.Length; i++)
{
Visit(newArray.Expressions[i]);
arr.SetValue(_value, i);
}
_value = arr;
}
protected override void VisitConditional(ConditionalExpression conditional)
{
Visit(conditional.Test);
if ((bool)_value)
{
Visit(conditional.IfTrue);
}
else
{
Visit(conditional.IfFalse);
}
}
protected override void VisitMethodCall(MethodCallExpression call)
{
if (call.Object != null)
{
Visit(call.Object);
}
object callObject = _value;
object[] arguments = VisitListExpressions(call.Arguments);
_value = call.Method.Invoke(callObject, arguments);
}
protected override void VisitParameter(ParameterExpression parameter)
{
for (int i = 0; i < _exp.Parameters.Count; i++)
{
if (_exp.Parameters[i].Name.Equals(parameter.Name))
{
_value = _args[i];
return;
}
}
_value = null;
}
protected override void VisitConstant(ConstantExpression constant)
{
_value = constant.Value;
}
protected override void VisitInvocation(InvocationExpression invocation)
{
Visit(invocation.Expression);
object o = _value;
object[] arguments = VisitListExpressions(invocation.Arguments);
_value = ((Delegate)o).DynamicInvoke(arguments);
}
protected override void VisitMemberListBinding(MemberListBinding binding)
{
object o = _value;
try
{
VisitMemberInfo(binding.Member);
base.VisitMemberListBinding(binding);
}
finally
{
_value = o;
}
}
protected override void VisitElementInitializer(ElementInit initializer)
{
object o = _value;
try
{
object[] arguments =
VisitListExpressions(initializer.Arguments);
initializer.AddMethod.Invoke(o, arguments);
}
finally
{
_value = o;
}
}
protected override void VisitMemberMemberBinding(MemberMemberBinding binding)
{
object o = _value;
try
{
VisitMemberInfo(binding.Member);
base.VisitMemberMemberBinding(binding);
}
finally
{
_value = o;
}
}
protected override void VisitMemberAssignment(MemberAssignment assignment)
{
object o = _value;
try
{
Visit(assignment.Expression);
switch (assignment.Member.MemberType)
{
case MemberTypes.Field:
((FieldInfo)assignment.Member).SetValue(o, _value);
return;
case MemberTypes.Property:
((PropertyInfo)assignment.Member).SetValue(o, _value, null);
return;
}
throw new NotImplementedException(
string.Format(
"Interpriter for MemberExpression with MemberType {0} is not implimented",
assignment.Member.MemberType));
}
finally
{
_value = o;
}
}
private object[] VisitListExpressions(ReadOnlyCollection<Expression> collection)
{
object o = _value;
try
{
object[] results = new object[collection.Count];
for (int i = 0; i < results.Length; i++)
{
Visit(collection[i]);
results[i] = _value;
}
return results;
}
finally
{
_value = o;
}
}
}
}