internal override Result Eval(Evaluator evaluater, Result[] argArray) {
if (_isFunction) {
return EvalFunc(evaluater, argArray);
} else {
return EvalProp(evaluater, argArray);
}
}
protected override void ProcessArg(Evaluator evaluater, Result[] argArray) {
base.ProcessArg(evaluater, argArray);
Type type0 = argArray[0].Type;
Type type1 = argArray[1].Type;
if (type0 == null && type1 == null) {
return;
}
if (type0 == null) {
if (type1.IsValueType) {
throw new InvalidCastException(string.Format("from null to {0}", type1.Name));
}
}
if (type1 == null) {
if (type0.IsValueType) {
throw new InvalidCastException(string.Format("from null to {0}", type0.Name));
}
}
int result;
if (BinaryHelper.ComparePrimitiveType(type0, type1, out result)) {
if (result > 0) {
argArray[1].Value = ConvertHelper.ChangeType(argArray[1].Value, type0);
} else if (result < 0) {
argArray[0].Value = ConvertHelper.ChangeType(argArray[0].Value, type1);
}
}
}
protected virtual void ProcessArg(Evaluator evaluater, Result[] argArray) {
if (argArray.Length != 2) {
throw new ArgumentException();
}
foreach (Result r in argArray) {
if (!IsEvalableType(r.Type)) {
throw new NotSupportedException();
}
}
}
Result EvalProp(Evaluator evaluater, Result[] argArray) {
if (argArray.Length == 0) {
throw new ArgumentException();
}
if (argArray.Length == 1) {
return argArray[0];
}
string memberName = argArray[1].Value as string;
if (memberName == null) {
throw new ArgumentException();
}
if (argArray[0] == null) {
throw new ArgumentNullException("argArray[0]");
}
object target = argArray[0].Value;
if (target == null) {
throw new ArgumentException();
}
Type type = null;
BindingFlags bindingFlags = BindingFlags.Default;
if (target is Type) {
type = (Type)target;
target = null;
bindingFlags = BindingFlags.Static;
} else {
type = target.GetType();
bindingFlags = BindingFlags.Instance;
}
bindingFlags |= BindingFlags.Public;
PropertyInfo pi = type.GetProperty(memberName, bindingFlags);
if (pi != null) {
return new Result(pi.PropertyType, pi.GetValue(target, null));
}
FieldInfo fi = type.GetField(memberName, bindingFlags);
if (fi != null) {
return new Result(fi.FieldType, fi.GetValue(target));
}
throw new ArgumentException();
}
Result EvalFunc(Evaluator evaluater, Result[] argArray) {
if (argArray.Length < 2) {
throw new ArgumentException();
}
if (argArray[0] == null || argArray[1] == null) {
throw new ArgumentNullException("argArray[0]");
}
object target = argArray[0].Value;
if (target == null) {
throw new ArgumentException();
}
string functionName = ConvertHelper.ToString(argArray[1].Value);
Type type = null;
BindingFlags bindingFlags = BindingFlags.Default;
if (target is Type) {
type = (Type)target;
target = null;
bindingFlags = BindingFlags.Static;
} else {
type = target.GetType();
bindingFlags = BindingFlags.Instance;
}
bindingFlags |= BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.OptionalParamBinding;
int length = argArray.Length - 2;
object[] argValueAry = new object[length];
for (int i = 0; i < length; i++) {
argValueAry[i] = argArray[i + 2].Value;
}
Binder defaultBinder = Type.DefaultBinder;
object ret = type.InvokeMember(functionName,
bindingFlags, defaultBinder, target, argValueAry);
if (ret != null)
return new Result(ret.GetType(), ret);
return new Result(null, null);
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
int ret = System.Convert.ToInt32(argArray[0].Value) & System.Convert.ToInt32(argArray[1].Value);
return new Result(typeof(int), ret);
}
protected override void ProcessArg(Evaluator evaluater, Result[] argArray)
{
base.ProcessArg(evaluater, argArray);
}
internal override Result Eval(Evaluator evaluater, Result[] argArray)
{
ProcessArg(evaluater, argArray);
return(DoEval(evaluater, argArray));
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
Type type = typeof(int);
int ret = System.Convert.ToInt32(argArray[0].Value) % System.Convert.ToInt32(argArray[1].Value);
return new Result(type, ConvertHelper.ChangeType(ret, type));
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray)
{
int ret = System.Convert.ToInt32(argArray[0].Value) & System.Convert.ToInt32(argArray[1].Value);
return(new Result(typeof(int), ret));
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
Type type = argArray[0].Type;
double ret = System.Convert.ToDouble(argArray[0].Value) / System.Convert.ToDouble(argArray[1].Value);
return new Result(type, ConvertHelper.ChangeType(ret, type));
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
return new Result(typeof(bool), (bool)argArray[0].Value && (bool)argArray[1].Value);
}
internal override Result Eval(Evaluator evaluater, Result[] argArray) {
ProcessArg(evaluater, argArray);
return DoEval(evaluater, argArray);
}
protected abstract Result DoEval(Evaluator evaluater, Result[] argArray);
protected abstract Result DoEval(Evaluator evaluater, Result[] argArray);
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
int result = 0;
if (argArray[0].IsNull() && argArray[1].IsNull()) {
return ProcessResult(0);
}
IComparable cb0 = argArray[0].Value as IComparable;
IComparable cb1 = argArray[1].Value as IComparable;
if (cb0 != null) {
result = cb0.CompareTo(argArray[1].Value);
} else if (cb1 != null) {
result = -cb1.CompareTo(argArray[0].Value);
} else {
throw new NotSupportedException();
}
return ProcessResult(result);
}
protected override void ProcessArg(Evaluator evaluater, Result[] argArray) {
base.ProcessArg(evaluater, argArray);
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray)
{
return(new Result(typeof(bool), (bool)argArray[0].Value && (bool)argArray[1].Value));
}
protected override void ProcessArg(Evaluator evaluater, Result[] argArray)
{
base.ProcessArg(evaluater, argArray);
Type type0 = argArray[0].Type;
Type type1 = argArray[1].Type;
int result;
if (type0 == null && type1 == null)
{
return;
}
if (type0 == null)
{
if (type1.IsValueType)
{
throw new InvalidCastException(string.Format("from null to {0}", type1.Name));
}
if (type1 == typeof(string))
{
argArray[0].Type = typeof(string);
return;
}
else
{
throw new InvalidCastException(string.Format("from null to {0}", type1.Name));
}
}
if (type1 == null)
{
if (type0.IsValueType)
{
throw new InvalidCastException(string.Format("from null to {0}", type0.Name));
}
if (type0 == typeof(string))
{
argArray[1].Type = typeof(string);
return;
}
else
{
throw new InvalidCastException(string.Format("from null to {0}", type0.Name));
}
}
if (BinaryHelper.ComparePrimitiveType(type0, type1, out result))
{
if (result > 0)
{
argArray[1].Value = ConvertHelper.ChangeType(argArray[1].Value, type0);
}
else if (result < 0)
{
argArray[0].Value = ConvertHelper.ChangeType(argArray[0].Value, type1);
}
}
else
{
throw new InvalidCastException(string.Format("from {1} to {0}", type0.Name, type1.Name));
}
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
int ret = 0;
if (_isleft)
ret = System.Convert.ToInt32(argArray[0].Value) << System.Convert.ToInt32(argArray[1].Value);
else {
ret = System.Convert.ToInt32(argArray[0].Value) >> System.Convert.ToInt32(argArray[1].Value);
}
return new Result(typeof(int), ret);
}
protected override Result DoEval(Evaluator evaluater, Result[] argArray) {
Type type0 = argArray[0].Type;
Type type1 = argArray[1].Type;
if (type0 == null && type1 == null) {
return new Result(null, null);
} else {
if (type0 == typeof(string))
return new Result(ConvertHelper.ToString(argArray[0].Value) + ConvertHelper.ToString(argArray[1].Value));
else {
double ret = System.Convert.ToDouble(argArray[0].Value) + System.Convert.ToDouble(argArray[1].Value);
return new Result(type0, ConvertHelper.ChangeType(ret, type0));
}
}
}
internal override Result Eval(Evaluator evaluater, Result[] argArray) {
if (argArray.Length < 2) {
throw new ArgumentException();
}
object target = argArray[0].Value;
if (target == null) {
throw new ArgumentException();
}
int length = argArray.Length - 1;
Type type = null;
BindingFlags bindingFlags = BindingFlags.Default;
if (target is Type) {
type = (Type)target;
target = null;
bindingFlags = BindingFlags.Static;
} else {
type = target.GetType();
bindingFlags = BindingFlags.Instance;
}
bindingFlags = BindingFlags.Public;
Type[] argTypeArray = new Type[length];
object[] argValueAry = new object[length];
for (int i = 0; i < length; i++) {
argTypeArray[i] = argArray[i + 1].Type;
argValueAry[i] = argArray[i + 1].Value;
}
Binder defaultBinder = Type.DefaultBinder;
PropertyInfo pi = type.GetProperty("Item", bindingFlags, defaultBinder, null, argTypeArray, null);
if (pi == null) {
pi = type.GetProperty("Items", bindingFlags, defaultBinder, null, argTypeArray, null);
}
if (pi != null) {
return new Result(pi.PropertyType, pi.GetValue(target, argValueAry));
}
if (target == null) {
throw new ArgumentException();
}
object ret;
if (target is string) {
string s = (string)target;
int index = (int)ConvertHelper.ChangeType(argArray[1].Value, typeof(int));
ret = s[index];
return new Result(typeof(char), ret);
}
if (target is Array) {
Array array = (Array)target;
if (array.Rank != (argArray.Length - 1)) {
throw new ArgumentException();
}
int[] indices = new int[length];
for (int i = 0; i < length; i++) {
indices[i] = (int)ConvertHelper.ChangeType(argArray[i + 1].Value, typeof(int));
}
ret = array.GetValue(indices);
if (ret != null)
return new Result(ret.GetType(), ret);
return new Result(null, null);
}
if (target is IList) {
IList list = (IList)target;
if (argArray.Length != 2) {
throw new ArgumentException();
}
int index = (int)ConvertHelper.ChangeType(argArray[1].Value, typeof(int));
ret = list[index];
if (ret != null)
return new Result(ret.GetType(), ret);
return new Result(null, null);
}
throw new ArgumentException();
}
internal override Result Eval(Evaluator evaluater, Result[] argArray) {
return new Result(_type, _value);
}
