private AssignStatement SetDelegate(LocalReference localDelegate, ReferenceExpression localTarget,
Type closedDelegateType, MethodInfo closedMethodOnTarget)
{
var delegateCreateDelegate = new MethodInvocationExpression(
null,
DelegateMethods.CreateDelegate,
new TypeTokenExpression(closedDelegateType),
localTarget,
new MethodTokenExpression(closedMethodOnTarget));
return new AssignStatement(localDelegate, new ConvertExpression(closedDelegateType, delegateCreateDelegate));
}
public static void CopyOutAndRefParameters(TypeReference[] dereferencedArguments, LocalReference invocation, MethodInfo method, MethodEmitter emitter)
{
var parameters = method.GetParameters();
if (!ArgumentsUtil.IsAnyByRef(parameters))
{
return; //saving the need to create locals if there is no need
}
var arguments = StoreInvocationArgumentsInLocal(emitter, invocation);
for (int i = 0; i < parameters.Length; i++)
{
if (!parameters[i].ParameterType.IsByRef) continue;
emitter.CodeBuilder.AddStatement(AssignArgument(dereferencedArguments, i, arguments));
}
}
private static LocalReference StoreInvocationArgumentsInLocal(MethodEmitter emitter, LocalReference invocation)
{
var invocationArgs = emitter.CodeBuilder.DeclareLocal(typeof(object[]));
emitter.CodeBuilder.AddStatement(GetArguments(invocationArgs, invocation));
return invocationArgs;
}
private static AssignStatement GetArguments(LocalReference invocationArgs, LocalReference invocation)
{
return new AssignStatement(invocationArgs, new MethodInvocationExpression(invocation, InvocationMethods.GetArguments));
}
private static AssignStatement AssignArgument(TypeReference[] dereferencedArguments, int i,
LocalReference invocationArgs)
{
return new AssignStatement(dereferencedArguments[i], Argument(i, invocationArgs, dereferencedArguments));
}
private static ConvertExpression Argument(int i, LocalReference invocationArgs, TypeReference[] arguments)
{
return new ConvertExpression(arguments[i].Type, new LoadRefArrayElementExpression(i, invocationArgs));
}
public LocalReference DeclareLocal(Type type)
{
LocalReference local = new LocalReference(type);
ilmarkers.Add(local);
return local;
}
public ByRefReference(LocalReference localReference)
: base(localReference.Type)
{
this.localReference = localReference;
}
private static void CopyOutAndRefParameters(
TypeReference[] dereferencedArguments, LocalReference invocationImplLocal, MethodInfo method,
MethodEmitter methodEmitter)
{
ParameterInfo[] parameters = method.GetParameters();
bool hasByRefParam = false;
for(int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
hasByRefParam = true;
}
if (!hasByRefParam)
return; //saving the need to create locals if there is no need
LocalReference invocationArgs = methodEmitter.CodeBuilder.DeclareLocal(typeof(object[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(invocationArgs,
new MethodInvocationExpression(invocationImplLocal, invocation_getArgumentsMethod)
)
);
for(int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(dereferencedArguments[i],
new ConvertExpression(dereferencedArguments[i].Type,
new LoadRefArrayElementExpression(i, invocationArgs)
)
));
}
}
}
private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method,
LocalReference invocationImplLocal)
{
Type[] genericParameters =
Array.FindAll(method.GetGenericArguments(), delegate(Type t) { return t.IsGenericParameter; });
LocalReference genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
methodEmitter.CodeBuilder.AddStatement(
new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));
for(int i = 0; i < genericParameters.Length; ++i)
{
methodEmitter.CodeBuilder.AddStatement(
new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
}
MethodInfo setGenericsArgs =
typeof(AbstractInvocation).GetMethod("SetGenericMethodArguments", new Type[] {typeof(Type[])});
methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
new MethodInvocationExpression(invocationImplLocal, setGenericsArgs,
new ReferenceExpression(
genericParamsArrayLocal))));
}
public ByRefReference(LocalReference localReference)
: base(localReference.Type)
{
this.localReference = localReference;
}
