protected override bool EmitInternal(TypeBinaryExpression node, EmittingContext context, GroboIL.Label returnDefaultValueLabel, ResultType whatReturn, bool extend, out Type resultType)
{
bool result;
GroboIL il = context.Il;
if (!node.Expression.Type.IsAssignableFrom(node.TypeOperand))
{
il.Ldc_I4(0);
result = false;
}
else if (node.Expression.Type == node.TypeOperand && node.TypeOperand.IsValueType)
{
il.Ldc_I4(1);
result = false;
}
else
{
Type operandType;
result = ExpressionEmittersCollection.Emit(node.Expression, context, returnDefaultValueLabel, ResultType.Value, extend, out operandType);
if (operandType.IsValueType)
{
using (var temp = context.DeclareLocal(operandType))
{
il.Stloc(temp);
il.Ldloca(temp);
}
}
var returnFalseLabel = il.DefineLabel("returnFalse");
il.Dup();
il.Brfalse(returnFalseLabel);
il.Call(typeof(object).GetMethod("GetType"), operandType);
il.Ldtoken(node.TypeOperand);
il.Call(typeof(Type).GetMethod("GetTypeFromHandle"));
il.Ceq();
var doneLabel = il.DefineLabel("done");
il.Br(doneLabel);
context.MarkLabelAndSurroundWithSP(returnFalseLabel);
il.Pop();
il.Ldc_I4(0);
context.MarkLabelAndSurroundWithSP(doneLabel);
}
resultType = typeof(bool);
return(result);
}
public static void EmitConstructionOfType(Type type, GroboIL il)
{
ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
if (constructor != null)
{
il.Newobj(constructor);
}
else
{
il.Ldtoken(type);
il.Call(getTypeFromHandle);
il.Call(getUninitializedObject);
if (type.IsValueType)
{
il.Unbox_Any(type);
}
else
{
il.Castclass(type);
}
}
}
private static void DefineMethodOverrideWithInterception(TypeBuilder typeBuilder, MethodBuilder methodBuilder, MethodInfo overridedMethod, Dictionary <Type, FieldInfo> interceptorFields, MethodInfo genericInterceptionAction, MethodInfo voidInterceptionAction, FieldBuilder concreteInstance, ParameterInfo[] methodParams, Type[] genericParameterTypes, Type[] interceptors)
{
var @delegate = GenerateOverloadedMethodDelegate(overridedMethod, typeBuilder, concreteInstance);
for (var i = 0; i < interceptors.Length; i++)
{
var interceptor = interceptors[i];
@delegate = DefineMethodInterceptingDelegate(typeBuilder, overridedMethod, interceptorFields, genericInterceptionAction, voidInterceptionAction, genericParameterTypes, @delegate, i, interceptor);
}
using (var il = new GroboIL(methodBuilder))
{
var paramInfoType = typeof(ParamInfo);
var paramsInfoType = typeof(ParamInfo[]);
var paramsInfo = il.DeclareLocal(paramsInfoType);
var paramInfo = il.DeclareLocal(paramInfoType);
il.Nop();
il.Ldc_I4(methodParams.Length);
il.Newarr(typeof(ParamInfo));
il.Stloc(paramsInfo);
var paramInfoConstructor = paramInfoType.GetConstructor(new[] { typeof(string), typeof(Type), typeof(bool), typeof(bool) });
var paramInfoValueSetter = paramInfoType.GetProperty("Value").GetSetMethod();
var getTypeMethod = typeof(Type).GetMethod("GetTypeFromHandle", new[] { typeof(RuntimeTypeHandle) });
var idx = 0;
foreach (var parameter in methodParams)
{
// load array at index
il.Ldloc(paramsInfo);
il.Ldc_I4(idx++);
// Load ParamInfo.Name
il.Ldstr(parameter.Name);
// Load ParamInfo.Type
if (parameter.IsOut || parameter.ParameterType.IsByRef)
{
il.Ldtoken(parameter.ParameterType.GetElementType());
}
else
{
il.Ldtoken(parameter.ParameterType);
}
il.Call(getTypeMethod);
// Load ParamInfo.IsByRef
if (parameter.ParameterType.IsByRef)
{
il.Ldc_I4(1);
}
else
{
il.Ldc_I4(0);
}
// Load ParamInfo.IsOut
if (parameter.IsOut)
{
il.Ldc_I4(1);
}
else
{
il.Ldc_I4(0);
}
// instantiate ParamInfo
il.Newobj(paramInfoConstructor);
il.Stloc(paramInfo);
// Set ParamInfo.Value
il.Ldloc(paramInfo);
il.Ldarg(parameter.Position + 1);
if (parameter.IsOut || parameter.ParameterType.IsByRef)
{
il.Ldobj(parameter.ParameterType.GetElementType());
if (parameter.ParameterType.GetElementType().IsValueType || parameter.ParameterType.GetElementType().IsGenericParameter)
{
il.Box(parameter.ParameterType.GetElementType());
}
}
else
{
if (parameter.ParameterType.IsValueType || parameter.ParameterType.IsGenericParameter)
{
il.Box(parameter.ParameterType);
}
}
il.Call(paramInfoValueSetter);
il.Nop();
// push to array
il.Ldloc(paramInfo);
il.Stelem(paramInfoType);
}
il.Ldarg(0);
il.Ldloc(paramsInfo);
if (overridedMethod.IsGenericMethodDefinition)
{
il.Call(@delegate.MakeGenericMethod(genericParameterTypes));
}
else
{
il.Call(@delegate);
}
idx = 1;
var paramInfoValueGetter = paramInfoType.GetProperty("Value").GetGetMethod();
foreach (var parameter in methodParams)
{
if (parameter.IsOut || parameter.ParameterType.IsByRef)
{
il.Ldarg(idx);
il.Ldloc(paramsInfo);
il.Ldc_I4(idx - 1);
il.Ldelem(paramInfoType);
il.Call(paramInfoValueGetter);
if (parameter.ParameterType.GetElementType().IsValueType)
{
il.Unbox_Any(parameter.ParameterType.GetElementType());
}
il.Stobj(parameter.ParameterType.GetElementType());
}
idx++;
}
il.Ret();
LogIlCode(il);
}
}