public opCodeSystemTypeConvert(iEvalTypedValue param1, System.Type Type)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
mValueDelegate = CType;
mSystemType = Type;
mEvalType = Globals.GetEvalType(Type);
}
private opCode GetLocalFunction(object @base, Type baseType, string funcName, IList <iEvalTypedValue> parameters, eCallType CallType)
{
MemberInfo mi;
iEvalTypedValue var;
mi = GetMemberInfo(baseType, funcName, parameters);
if (mi != null)
{
switch (mi.MemberType)
{
case MemberTypes.Field:
{
if ((CallType & eCallType.field) == 0)
{
mTokenizer.RaiseError("Unexpected Field");
}
break;
}
case MemberTypes.Method:
{
if ((CallType & eCallType.method) == 0)
{
mTokenizer.RaiseError("Unexpected Method");
}
break;
}
case MemberTypes.Property:
{
if ((CallType & eCallType.property) == 0)
{
mTokenizer.RaiseError("Unexpected Property");
}
break;
}
default:
{
mTokenizer.RaiseUnexpectedToken(mi.MemberType.ToString() + " members are not supported");
break;
}
}
return(opCodeCallMethod.GetNew(mTokenizer, @base, mi, parameters));
}
if (@base is iVariableBag)
{
iEvalTypedValue val = ((iVariableBag)@base).GetVariable(funcName);
if (val != null)
{
return(new opCodeGetVariable(val));
}
}
return(null /* TODO Change to default(_) if this is not a reference type */);
}
public opCodeGetArrayEntry(opCode array, IList <iEvalTypedValue> @params)
{
iEvalTypedValue[] newParams = new iEvalTypedValue[@params.Count - 1 + 1];
int[] newValues = new int[@params.Count - 1 + 1];
@params.CopyTo(newParams, 0);
mArray = array;
mArray.ValueChanged += mBaseVariable_ValueChanged;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType();
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
protected static void ConvertToSystemType(ref iEvalTypedValue param1, Type SystemType)
{
if (param1.SystemType != SystemType)
{
if (SystemType == typeof(object))
{
}
else
{
param1 = new opCodeSystemTypeConvert(param1, SystemType);
}
}
}
public opCodeConvert(tokenizer tokenizer, iEvalTypedValue param1, EvalType EvalType)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
switch (EvalType)
{
case EvalType.Boolean:
{
mValueDelegate = TBool;
mEvalType = EvalType.Boolean;
break;
}
case EvalType.Date:
{
mValueDelegate = TDate;
mEvalType = EvalType.Date;
break;
}
case EvalType.Number:
{
mValueDelegate = TNum;
mEvalType = EvalType.Number;
break;
}
case EvalType.String:
{
mValueDelegate = TStr;
mEvalType = EvalType.String;
break;
}
default:
{
tokenizer.RaiseError("Cannot convert " + param1.SystemType.Name + " to " + EvalType);
break;
}
}
}
public opCodeSystemTypeConvert(iEvalTypedValue param1, Type Type)
{
mParam1 = param1;
mValueDelegate = CType;
mSystemType = Type;
mEvalType = Globals.GetEvalType(Type);
}
public opCodeConvert(tokenizer tokenizer, iEvalTypedValue param1, EvalType EvalType)
{
mParam1 = param1;
switch (EvalType)
{
case EvalType.Boolean:
mValueDelegate = TBool;
mEvalType = EvalType.Boolean;
break;
case EvalType.Date:
mValueDelegate = TDate;
mEvalType = EvalType.Date;
break;
case EvalType.Number:
mValueDelegate = TNum;
mEvalType = EvalType.Number;
break;
case EvalType.String:
mValueDelegate = TStr;
mEvalType = EvalType.String;
break;
default:
tokenizer.RaiseError("Cannot convert " + param1.SystemType.Name + " to " + EvalType);
break;
}
}
protected static void ConvertToSystemType(ref iEvalTypedValue param1, Type SystemType)
{
if ((!object.ReferenceEquals(param1.SystemType, SystemType)))
{
if (object.ReferenceEquals(SystemType, typeof(object)))
{
}
//ignore
else
{
param1 = new opCodeSystemTypeConvert(param1, SystemType);
}
}
}
public string TStr(iEvalTypedValue o)
{
return (string)o.Value;
}
public double TNum(iEvalTypedValue o)
{
return (double)o.Value;
}
public DateTime TDate(iEvalTypedValue o)
{
return (DateTime)o.Value;
}
public bool TBool(iEvalTypedValue o)
{
return (bool)o.Value;
}
public static DateTime TDate(iEvalTypedValue o)
{
return((DateTime)o.Value);
}
public opCodeGetVariable(iEvalTypedValue value)
{
mParam1 = value;
}
private iEvalValue mResultValue; // just for some
internal opCodeCallMethod(object baseObject, System.Reflection.MemberInfo method, IList <iEvalTypedValue> @params)
{
if (@params == null)
{
@params = new iEvalTypedValue[] { }
}
;
iEvalTypedValue[] newParams = new iEvalTypedValue[@params.Count - 1 + 1];
object[] newParamValues = new object[@params.Count - 1 + 1];
@params.CopyTo(newParams, 0);
foreach (iEvalTypedValue p in newParams)
{
p.ValueChanged += mParamsValueChanged;
}
mParams = newParams;
mParamValues = newParamValues;
mBaseObject = baseObject;
mMethod = method;
if (mBaseObject is iEvalValue)
{
if (mBaseObject is iEvalTypedValue)
{
{
var withBlock = (iEvalTypedValue)mBaseObject;
mBaseSystemType = withBlock.SystemType;
mBaseEvalType = withBlock.EvalType;
}
}
else
{
mBaseSystemType = mBaseObject.GetType();
mBaseEvalType = Globals.GetEvalType(mBaseSystemType);
}
}
else
{
mBaseSystemType = mBaseObject.GetType();
mBaseEvalType = Globals.GetEvalType(mBaseSystemType);
}
System.Reflection.ParameterInfo[] paramInfo = null;
if (method is System.Reflection.PropertyInfo)
{
{
var withBlock = (System.Reflection.PropertyInfo)method;
mResultSystemType = withBlock.PropertyType;
paramInfo = withBlock.GetIndexParameters();
}
mValueDelegate = GetProperty;
}
else if (method is System.Reflection.MethodInfo)
{
{
var withBlock = (System.Reflection.MethodInfo)method;
mResultSystemType = withBlock.ReturnType;
paramInfo = withBlock.GetParameters();
}
mValueDelegate = GetMethod;
}
else if (method is System.Reflection.FieldInfo)
{
{
var withBlock = (System.Reflection.FieldInfo)method;
mResultSystemType = withBlock.FieldType;
paramInfo = new System.Reflection.ParameterInfo[] { };
}
mValueDelegate = GetField;
}
for (int i = 0; i <= mParams.Length - 1; i++)
{
if (i < paramInfo.Length)
{
ConvertToSystemType(ref mParams[i], paramInfo[i].ParameterType);
}
}
if (typeof(iEvalValue).IsAssignableFrom(mResultSystemType))
{
mResultValue = (iEvalValue)InternalValue();
if (mResultValue is iEvalTypedValue)
{
{
var withBlock = (iEvalTypedValue)mResultValue;
mResultSystemType = withBlock.SystemType;
mResultEvalType = withBlock.EvalType;
}
}
else if (mResultValue == null)
{
mResultSystemType = typeof(object);
mResultEvalType = EvalType.Object;
}
else
{
object v = mResultValue.Value;
if (v == null)
{
mResultSystemType = typeof(object);
mResultEvalType = EvalType.Object;
}
else
{
mResultSystemType = v.GetType();
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
}
}
else
{
mResultSystemType = SystemType;
mResultEvalType = Globals.GetEvalType(SystemType);
}
if (mBaseValue != null)
{
mBaseValue.ValueChanged += mBaseVariable_ValueChanged;
}
if (mResultValue != null)
{
mResultValue.ValueChanged += mResultVariable_ValueChanged;
}
}
public opCodeGetVariable(iEvalTypedValue value)
{
mParam1 = value;
mParam1.ValueChanged += mParam1_ValueChanged;
}
public static double TNum(iEvalTypedValue o)
{
return(System.Convert.ToDouble(o.Value));
}
public static string TStr(iEvalTypedValue o)
{
return(System.Convert.ToString(o.Value));
}
public opCodeGetArrayEntry(opCode array, IList @params)
{
iEvalTypedValue[] newParams = new iEvalTypedValue[@params.Count];
int[] newValues = new int[@params.Count];
@params.CopyTo(newParams, 0);
mArray = array;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType;
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
public static bool TBool(iEvalTypedValue o)
{
return(System.Convert.ToBoolean(o.Value));
}
