public OPCodeSystemTypeConvert(IEvalTypedValue param1, Type type)
{
Param1 = param1;
mValueDelegate = CType;
mSystemType = type;
mEvalType = Globals.GetEvalType(type);
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="array">Array to Index</param>
/// <param name="params">The Parameter of the Index Operation</param>
public OPCodeGetArrayEntry(OPCode array, IList @params)
{
IEvalTypedValue[] newParams = new IEvalTypedValue[@params.Count];
int[] newValues = new int[@params.Count];
@params.CopyTo(newParams, 0);
Array = array;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType();
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
/// <summary>
/// Converts an IEvalTypedValue to the Specified System Type
/// </summary>
/// <param name="param1"></param>
/// <param name="systemType"></param>
protected static void ConvertToSystemType(ref IEvalTypedValue param1, Type systemType)
{
if (!ReferenceEquals(param1.SystemType, systemType))
{
if (ReferenceEquals(systemType, typeof(object)))
{
}
// ignore
else
{
param1 = new OPCodeSystemTypeConvert(param1, systemType);
}
}
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="tokenizer">Tokenizer Instance</param>
/// <param name="param1">The First Parameter</param>
/// <param name="evalType">The Evaluator Type</param>
public OPCodeConvert(Tokenizer tokenizer, IEvalTypedValue param1, EvalType evalType)
{
Param1 = 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 " +
(int)evalType
);
break;
}
}
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="value">IEvalTypedValue to Get the Variable From</param>
public OPCodeGetVariable(IEvalTypedValue value)
{
mParam1 = value;
}
/// <summary>
/// Internal Constructor
/// </summary>
/// <param name="baseObject">The Base Object Instance</param>
/// <param name="method">The Member Info</param>
/// <param name="params">The Parameters of the Call</param>
internal OPCodeCallMethod(object baseObject, MemberInfo method, IList @params)
{
if (@params is null)
{
@params = new IEvalTypedValue[] { };
}
IEvalTypedValue[] newParams = new IEvalTypedValue[@params.Count];
object[] newParamValues = new object[@params.Count];
@params.CopyTo(newParams, 0);
foreach (IEvalTypedValue p in newParams)
{
p.ValueChanged += ParamsValueChanged;
}
mParams = newParams;
mParamValues = newParamValues;
_baseObject = baseObject;
mMethod = method;
if (_baseObject is IEvalValue)
{
if (_baseObject is IEvalTypedValue)
{
{
IEvalTypedValue withBlock = (IEvalTypedValue)_baseObject;
}
}
}
ParameterInfo[] paramInfo = default;
if (method is PropertyInfo)
{
{
PropertyInfo withBlock1 = (PropertyInfo)method;
mResultSystemType = ((PropertyInfo)method).PropertyType;
paramInfo = withBlock1.GetIndexParameters();
}
mValueDelegate = GetProperty;
}
else if (method is MethodInfo)
{
{
MethodInfo withBlock2 = (MethodInfo)method;
mResultSystemType = withBlock2.ReturnType;
paramInfo = withBlock2.GetParameters();
}
mValueDelegate = GetMethod;
}
else if (method is FieldInfo)
{
{
FieldInfo withBlock3 = (FieldInfo)method;
mResultSystemType = withBlock3.FieldType;
paramInfo = new ParameterInfo[] { };
}
mValueDelegate = GetField;
}
for (int i = 0, loopTo = mParams.Length - 1; i <= loopTo; i++)
{
if (i < paramInfo.Length)
{
ConvertToSystemType(ref mParams[i], paramInfo[i].ParameterType);
}
}
if (typeof(IEvalValue).IsAssignableFrom(mResultSystemType))
{
ResultValue = (IEvalValue)InternalValue();
if (ResultValue is IEvalTypedValue)
{
{
IEvalTypedValue withBlock4 = (IEvalTypedValue)ResultValue;
mResultSystemType = withBlock4.SystemType;
_resultEvalType = withBlock4.EvalType;
}
}
else if (ResultValue is null)
{
mResultSystemType = typeof(object);
_resultEvalType = EvalType.Object;
}
else
{
object v = ResultValue.Value;
if (v is null)
{
mResultSystemType = typeof(object);
_resultEvalType = EvalType.Object;
}
else
{
mResultSystemType = v.GetType();
_resultEvalType = Globals.GetEvalType(mResultSystemType);
}
}
}
else
{
mResultSystemType = SystemType;
_resultEvalType = Globals.GetEvalType(SystemType);
}
}
/// <summary>
/// Returns the String Value from the IEvalTypedValue Object
/// </summary>
/// <param name="o">The IEvalTypedValue Object</param>
/// <returns>String Value</returns>
public static string Str(IEvalTypedValue o)
{
return(Convert.ToString(o.Value));
}
/// <summary>
/// Returns the Number Value from the IEvalTypedValue Object
/// </summary>
/// <param name="o">The IEvalTypedValue Object</param>
/// <returns>Number Value</returns>
public static double Num(IEvalTypedValue o)
{
return(Convert.ToDouble(o.Value));
}
/// <summary>
/// Returns the DateTime Value from the IEvalTypedValue Object
/// </summary>
/// <param name="o">The IEvalTypedValue Object</param>
/// <returns>DateTime Value</returns>
public static DateTime Date(IEvalTypedValue o)
{
return(Convert.ToDateTime(o.Value));
}
/// <summary>
/// Returns the Boolean Value from the IEvalTypedValue Object
/// </summary>
/// <param name="o">The IEvalTypedValue Object</param>
/// <returns>Boolean Value</returns>
public static bool Bool(IEvalTypedValue o)
{
return(Convert.ToBoolean(o.Value));
}
