protected override bool EmitInternal(BinaryExpression node, EmittingContext context, GroboIL.Label returnDefaultValueLabel, ResultType whatReturn, bool extend, out Type resultType)
{
if (node.Conversion != null)
{
throw new NotSupportedException("Coalesce with conversion is not supported");
}
// note ich: баг решарпера
// ReSharper disable HeuristicUnreachableCode
var left = node.Left;
var right = node.Right;
GroboIL il = context.Il;
GroboIL.Label valueIsNullLabel = il.DefineLabel("valueIsNull");
Type leftType;
bool labelUsed = ExpressionEmittersCollection.Emit(left, context, valueIsNullLabel, out leftType);
if (left.Type.IsValueType)
{
using (var temp = context.DeclareLocal(left.Type))
{
il.Stloc(temp);
il.Ldloca(temp);
}
}
labelUsed |= context.EmitNullChecking(left.Type, valueIsNullLabel);
if (left.Type.IsValueType)
{
if (!left.Type.IsNullable())
{
throw new InvalidOperationException("Type '" + left.Type + "' cannot be null");
}
if (node.Type != left.Type)
{
context.EmitValueAccess(left.Type);
}
else
{
il.Ldobj(left.Type);
}
}
var valueIsNotNullLabel = il.DefineLabel("valueIsNotNull");
il.Br(valueIsNotNullLabel);
if (labelUsed)
{
context.MarkLabelAndSurroundWithSP(valueIsNullLabel);
il.Pop();
}
Type rightType;
var result = ExpressionEmittersCollection.Emit(right, context, returnDefaultValueLabel, out rightType);
context.MarkLabelAndSurroundWithSP(valueIsNotNullLabel);
resultType = node.Type;
return(result);
// ReSharper restore HeuristicUnreachableCode
}
public void TestFarsh()
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(int), new[] { typeof(int) }, typeof(Test));
using (var il = new GroboIL(method))
{
var temp = il.DeclareLocal(typeof(int));
il.Ldarg(0); // stack: [x]
var label0 = il.DefineLabel("L");
il.Br(label0); // goto L_0; stack: [x]
il.Ldstr("zzz");
il.Ldobj(typeof(DateTime));
il.Mul();
il.Initobj(typeof(int));
var label1 = il.DefineLabel("L");
il.MarkLabel(label1); // stack: [x, 2]
il.Stloc(temp); // temp = 2; stack: [x]
var label2 = il.DefineLabel("L");
il.MarkLabel(label2); // stack: [cur]
il.Ldarg(0); // stack: [cur, x]
il.Mul(); // stack: [cur * x = cur]
il.Ldloc(temp); // stack: [cur, temp]
il.Ldc_I4(1); // stack: [cur, temp, 1]
il.Sub(); // stack: [cur, temp - 1]
il.Stloc(temp); // temp = temp - 1; stack: [cur]
il.Ldloc(temp); // stack: [cur, temp]
il.Ldc_I4(0); // stack: [cur, temp, 0]
il.Bgt(label2, false); // if(temp > 0) goto L_2; stack: [cur]
var label3 = il.DefineLabel("L");
il.Br(label3); // goto L_3; stack: [cur]
il.MarkLabel(label0); // stack: [x]
il.Ldc_I4(2); // stack: [x, 2]
il.Br(label1); // goto L_1; stack: [x, 2]
il.MarkLabel(label3); // stack: [cur]
il.Ret(); // return cur; stack: []
Console.Write(il.GetILCode());
}
}
private void PointerToValue() => Generator.Ldobj(typeof(BitsValue));
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);
}
}