protected virtual Expression VisitValue(ValueExpression expression)
{
return expression;
}
protected virtual Expression VisitValue(ValueExpression expression)
{
return(expression);
}
private ValueExpression Evaluate(IParserContext context, bool assign, object newValue)
{
ValueExpression targetValue = _target.Evaluate(context);
object targetObject;
Type targetType;
if (targetValue.Value is ClassName)
{
targetType = ((ClassName)targetValue.Value).Type;
targetObject = null;
}
else
{
targetType = targetValue.Type;
targetObject = targetValue.Value;
if (targetObject == null)
{
return(new ValueExpression(TokenPosition, null, targetType));
}
}
if (targetObject is IDynamicObject)
{
object value;
Type type;
if (((IDynamicObject)targetObject).TryGetValue(_member, out value, out type))
{
return(new ValueExpression(TokenPosition, value, type));
}
}
MemberInfo[] members = FindMemberInHierarchy(targetType, _member); // targetType.GetMember(_member);
if (members.Length == 0)
{
PropertyInfo indexerPropInfo = targetType.Inspector().GetIndexer(new[] { typeof(string) });
if (indexerPropInfo != null)
{
return(new ValueExpression(TokenPosition, indexerPropInfo.GetValue(targetObject, new object[] { _member }), indexerPropInfo.PropertyType));
}
throw new UnknownPropertyException("Unknown property " + _member + " for object " + _target + " (type " + targetType.Name + ")", this);
}
if (members.Length >= 1 && members[0] is MethodInfo)
{
if (targetObject == null)
{
return(Exp.Value(TokenPosition, new StaticMethod(targetType, _member)));
}
else
{
return(Exp.Value(TokenPosition, new InstanceMethod(targetType, _member, targetObject)));
}
}
MemberInfo member = members[0];
if (members.Length > 1 && targetObject != null) // CoolStorage, ActiveRecord and Dynamic Proxy frameworks sometimes return > 1 member
{
foreach (MemberInfo mi in members)
{
if (mi.DeclaringType == targetObject.GetType())
{
member = mi;
}
}
}
if (assign)
{
if (member is FieldInfo)
{
((FieldInfo)member).SetValue(targetObject, newValue);
}
if (member is PropertyInfo)
{
((PropertyInfo)member).SetValue(targetObject, newValue, null);
}
// Fall through to get the new property/field value below
}
if (member is FieldInfo)
{
return(new ValueExpression(TokenPosition, ((FieldInfo)member).GetValue(targetObject), ((FieldInfo)member).FieldType));
}
if (member is PropertyInfo)
{
return(new ValueExpression(TokenPosition, ((PropertyInfo)member).GetValue(targetObject, null), ((PropertyInfo)member).PropertyType));
}
throw new ExpressionEvaluationException(_member + " is not a field or property", this);
}
IValueWithType IExpression.Evaluate(IParserContext context)
{
ValueExpression value = Evaluate(context);
return(new ValueExpression(TokenPosition, value.Value, value.Type));
}
public ValueExpression Evaluate(IParserContext context, bool assign, object newValue)
{
ValueExpression targetValue = Target.Evaluate(context);
Type targetType = targetValue.Type;
object targetObject = targetValue.Value;
ValueExpression[] parameters = EvaluateExpressionArray(Parameters, context);
Type[] parameterTypes = parameters.ConvertAll(expr => expr.Type);
object[] parameterValues = parameters.ConvertAll(expr => expr.Value);
if (targetType.IsArray)
{
if (targetType.GetArrayRank() != parameters.Length)
{
throw new Exception("Array has a different rank. Number of arguments is incorrect");
}
Type returnType = targetType.GetElementType();
bool useLong = false;
foreach (Type t in parameterTypes)
{
if (t == typeof(long) || t == typeof(long?))
{
useLong = true;
}
else if (t != typeof(int) & t != typeof(int?) && t != typeof(short) && t != typeof(short?) && t != typeof(ushort) && t != typeof(ushort?))
{
throw new BadArgumentException(t.GetType().Name + " is not a valid type for array indexers", this);
}
}
#if !PCL
if (useLong)
{
long[] indexes = new long[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
indexes[i] = Convert.ToInt64(parameterValues[i]);
}
if (assign)
{
((Array)targetObject).SetValue(newValue, indexes);
}
return(Exp.Value(TokenPosition, ((Array)targetObject).GetValue(indexes), returnType));
}
else
#endif
{
int[] indexes = new int[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
indexes[i] = Convert.ToInt32(parameterValues[i]);
}
if (assign)
{
((Array)targetObject).SetValue(newValue, indexes);
}
return(Exp.Value(TokenPosition, ((Array)targetObject).GetValue(indexes), returnType));
}
}
else
{
DefaultMemberAttribute[] att = targetType.Inspector().GetCustomAttributes <DefaultMemberAttribute>(true);
MethodInfo methodInfo = targetType.Inspector().GetPropertyGetter(att[0].MemberName, parameterTypes);
object value = methodInfo.Invoke(targetObject, parameterValues);
return(new ValueExpression(TokenPosition, value, methodInfo.ReturnType));
}
}
