public void Emit(ILGenerator gen)
{
if (reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
}
else if (expression != null)
{
expression.Emit(gen);
}
gen.Emit(OpCodes.Ret);
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
var notNull = gen.DefineLabel();
gen.Emit(OpCodes.Brtrue_S, notNull);
ifNull.Emit(member, gen);
gen.MarkLabel(notNull);
if (ifNotNull != null) // yeah, I know that reads funny :)
{
ifNotNull.Emit(member, gen);
}
}
internal EasyMethod(AbstractEasyType maintype, String name,
MethodAttributes attrs,
ReturnReferenceExpression returnRef, params ArgumentReference[] arguments)
{
_maintype = maintype;
_arguments = arguments;
Type returnType = returnRef.Type;
Type[] args = ArgumentsUtil.InitializeAndConvert(arguments);
_builder = maintype.TypeBuilder.DefineMethod(name, attrs,
returnType, args);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Enter", new Type[] { typeof(object) }));
gen.BeginExceptionBlock();
foreach (Statement statement in this._stmts)
{
statement.Emit(member, gen);
}
gen.BeginFinallyBlock();
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Exit"));
gen.EndExceptionBlock();
}
public EasyMethod CreateSetMethod(MethodAttributes attrs, params Type[] parameters)
{
if (_setMethod != null)
{
return(_setMethod);
}
_setMethod = new EasyMethod(_maintype, "set_" + _builder.Name,
attrs,
new ReturnReferenceExpression(typeof(void)),
ArgumentsUtil.ConvertToArgumentReference(parameters));
return(_setMethod);
}
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
{
var targetReference = getTargetReference(@class, MethodToOverride);
var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
emitter.CodeBuilder.AddStatement(new ReturnStatement(
new MethodInvocationExpression(
targetReference,
MethodToOverride,
arguments)
{
VirtualCall = true
}));
return(emitter);
}
private IStatement IfNotNull(Reference targetReference)
{
var statements = new BlockStatement();
var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
statements.AddStatement(new ReturnStatement(
new MethodInvocationExpression(
targetReference,
MethodToOverride,
arguments)
{
VirtualCall = true
}));
return(statements);
}
private Expression IfNotNull(Reference targetReference)
{
var expression = new MultiStatementExpression();
var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
expression.AddStatement(new ReturnStatement(
new MethodInvocationExpression(
targetReference,
MethodToOverride,
arguments)
{
VirtualCall = true
}));
return(expression);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
if (this._reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._reference, gen);
}
else if (this._expression != null)
{
this._expression.Emit(member, gen);
}
else if (member.ReturnType != typeof(void))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, member.ReturnType);
}
gen.Emit(OpCodes.Ret);
}
private void ReplicateBaseTypeConstructor(ConstructorInfo constructor, Action <ConstructorEmitter> preStatementsAdder, Action <ConstructorEmitter> postStatementsAdder)
{
ArgumentUtility.CheckNotNull("constructor", constructor);
ArgumentUtility.CheckNotNull("preStatementsAdder", preStatementsAdder);
ArgumentUtility.CheckNotNull("postStatementsAdder", postStatementsAdder);
ArgumentReference[] arguments = ArgumentsUtil.ConvertToArgumentReference(constructor.GetParameters());
ConstructorEmitter newConstructor = InnerEmitter.CreateConstructor(arguments);
preStatementsAdder(newConstructor);
Expression[] argumentExpressions = ArgumentsUtil.ConvertArgumentReferenceToExpression(arguments);
newConstructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(constructor, argumentExpressions));
postStatementsAdder(newConstructor);
newConstructor.CodeBuilder.AddStatement(new ReturnStatement());
}
private Type GetDelegateType(MetaMethod method, ClassEmitter @class)
{
var scope = @class.ModuleScope;
var key = new CacheKey(
typeof(Delegate),
targetType,
new[] { method.MethodOnTarget.ReturnType }
.Concat(ArgumentsUtil.GetTypes(method.MethodOnTarget.GetParameters())).
ToArray(),
null);
return(scope.TypeCache.GetOrAddWithoutTakingLock(key, _ =>
new DelegateTypeGenerator(method, targetType)
.Generate(@class, namingScope)
.BuildType()));
}
public void Emit(ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(owner, gen);
foreach (var exp in args)
{
exp.Emit(gen);
}
if (VirtualCall)
{
gen.Emit(OpCodes.Callvirt, method);
}
else
{
gen.Emit(OpCodes.Call, method);
}
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(owner, gen);
foreach (Expression exp in args)
{
exp.Emit(member, gen);
}
if (virtualCall)
{
gen.Emit(OpCodes.Callvirt, method);
}
else
{
gen.Emit(OpCodes.Call, method);
}
}
public void Emit(IMemberEmitter member, ILGenerator gen)
{
if (reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
}
else if (expression != null)
{
expression.Emit(member, gen);
}
else
{
if (member.ReturnType != typeof(void))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, member.ReturnType);
}
}
gen.Emit(OpCodes.Ret);
}
public void Emit(ILGenerator gen)
{
if (reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
}
else if (expression != null)
{
expression.Emit(gen);
}
var notNull = gen.DefineLabel();
gen.Emit(OpCodes.Brtrue_S, notNull);
ifNull.Emit(gen);
gen.MarkLabel(notNull);
if (ifNotNull != null) // yeah, I know that reads funny :)
{
ifNotNull.Emit(gen);
}
}
protected virtual EasyConstructor GenerateConstructor(ConstructorInfo baseConstructor)
{
ArrayList list = new ArrayList();
ArgumentReference reference = new ArgumentReference(base.Context.Interceptor);
ArgumentReference reference2 = new ArgumentReference(typeof(object[]));
list.Add(reference);
ParameterInfo[] parameters = baseConstructor.GetParameters();
if (base.Context.HasMixins)
{
list.Add(reference2);
}
ArgumentReference[] c = ArgumentsUtil.ConvertToArgumentReference(parameters);
list.AddRange(c);
EasyConstructor constructor = base.MainTypeBuilder.CreateConstructor((ArgumentReference[])list.ToArray(typeof(ArgumentReference)));
this.GenerateConstructorCode(constructor.CodeBuilder, reference, SelfReference.Self, reference2);
constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, c);
constructor.CodeBuilder.AddStatement(new ReturnStatement());
return(constructor);
}
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));
}
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
var local = gen.DeclareLocal(typeof(object[]));
gen.Emit(OpCodes.Ldc_I4, args.Length);
gen.Emit(OpCodes.Newarr, typeof(object));
gen.Emit(OpCodes.Stloc, local);
for (var i = 0; i < args.Length; i++)
{
gen.Emit(OpCodes.Ldloc, local);
gen.Emit(OpCodes.Ldc_I4, i);
var reference = args[i];
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
if (reference.Type.GetTypeInfo().IsByRef)
{
throw new NotSupportedException();
}
if (reference.Type.GetTypeInfo().IsPointer)
{
gen.Emit(OpCodes.Call, ArgumentsUtil.IntPtrFromPointer());
gen.Emit(OpCodes.Box, typeof(IntPtr));
}
if (reference.Type.GetTypeInfo().IsValueType)
{
gen.Emit(OpCodes.Box, reference.Type);
}
else if (reference.Type.GetTypeInfo().IsGenericParameter)
{
gen.Emit(OpCodes.Box, reference.Type);
}
gen.Emit(OpCodes.Stelem_Ref);
}
gen.Emit(OpCodes.Ldloc, local);
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
LocalBuilder local = gen.DeclareLocal(typeof(object[]));
gen.Emit(OpCodes.Ldc_I4, args.Length);
gen.Emit(OpCodes.Newarr, typeof(object));
gen.Emit(OpCodes.Stloc, local);
for (int i = 0; i < args.Length; i++)
{
gen.Emit(OpCodes.Ldloc, local);
gen.Emit(OpCodes.Ldc_I4, i);
TypeReference reference = args[i];
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
if (reference.Type.IsByRef)
{
throw new NotSupportedException();
}
if (reference.Type.IsValueType)
{
gen.Emit(OpCodes.Box, reference.Type.UnderlyingSystemType);
}
if (reference.Type.IsGenericParameter)
{
gen.Emit(OpCodes.Box, reference.Type);
}
gen.Emit(OpCodes.Stelem_Ref);
}
gen.Emit(OpCodes.Ldloc, local);
}
public void Emit(ILGenerator gen)
{
var local = gen.DeclareLocal(typeof(object[]));
gen.Emit(OpCodes.Ldc_I4, args.Length);
gen.Emit(OpCodes.Newarr, typeof(object));
gen.Emit(OpCodes.Stloc, local);
for (var i = 0; i < args.Length; i++)
{
gen.Emit(OpCodes.Ldloc, local);
gen.Emit(OpCodes.Ldc_I4, i);
var reference = args[i];
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
if (reference.Type.IsByRef)
{
throw new NotSupportedException();
}
if (reference.Type.IsValueType)
{
gen.Emit(OpCodes.Box, reference.Type);
}
else if (reference.Type.IsGenericParameter)
{
gen.Emit(OpCodes.Box, reference.Type);
}
gen.Emit(OpCodes.Stelem_Ref);
}
gen.Emit(OpCodes.Ldloc, local);
}
public EasyMethod CreateGetMethod(MethodAttributes attrs, params Type[] parameters)
{
if (this._getMethod == null)
{
this._getMethod = new EasyMethod(this._maintype, "get_" + this._builder.Name, attrs, new ReturnReferenceExpression(this.ReturnType), ArgumentsUtil.ConvertToArgumentReference(parameters));
}
return(this._getMethod);
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
right.Emit(member, gen);
if (fromType == target)
{
return;
}
if (fromType.IsByRef)
{
fromType = fromType.GetElementType();
}
if (target.IsByRef)
{
target = target.GetElementType();
}
if (target.IsPointer && fromType == typeof(object))
{
gen.Emit(OpCodes.Unbox_Any, typeof(IntPtr));
gen.Emit(OpCodes.Call, ArgumentsUtil.PointerFromIntPtr());
}
else if (target == typeof(object) && fromType.IsPointer)
{
gen.Emit(OpCodes.Call, ArgumentsUtil.IntPtrFromPointer());
gen.Emit(OpCodes.Box, typeof(IntPtr));
}
else if (target.IsValueType)
{
if (fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types");
}
else
{
// Unbox conversion
// Assumes fromType is a boxed value
// if we can, we emit a box and ldind, otherwise, we will use unbox.any
if (LdindOpCodesDictionary.Instance[target] != LdindOpCodesDictionary.EmptyOpCode)
{
gen.Emit(OpCodes.Unbox, target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, target);
}
else
{
gen.Emit(OpCodes.Unbox_Any, target);
}
}
}
else
{
if (fromType.IsValueType)
{
// Box conversion
gen.Emit(OpCodes.Box, fromType);
EmitCastIfNeeded(typeof(object), target, gen);
}
else
{
// Possible down-cast
EmitCastIfNeeded(fromType, target, gen);
}
}
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(reference.OwnerReference, gen);
reference.LoadAddressOfReference(gen);
}
public void InvokeBaseConstructor(ConstructorInfo constructor, params ArgumentReference[] arguments)
{
AddStatement(
new ConstructorInvocationStatement(constructor,
ArgumentsUtil.ConvertArgumentReferenceToExpression(arguments)));
}
public void Emit(ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(argument, gen);
expression.Emit(gen);
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(target.OwnerReference, gen);
expression.Emit(member, gen);
target.StoreReference(gen);
}
public EasyRuntimeConstructor(AbstractEasyType maintype, params ArgumentReference[] arguments)
{
Type[] parameterTypes = ArgumentsUtil.InitializeAndConvert(arguments);
base._builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public, CallingConventions.Standard, parameterTypes);
base._builder.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);
}
internal EasyConstructor(AbstractEasyType maintype, params ArgumentReference[] arguments)
{
this._maintype = maintype;
Type[] parameterTypes = ArgumentsUtil.InitializeAndConvert(arguments);
this._builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes);
}
public EasyMethod CreateRemoveOnMethod(MethodAttributes atts, params Type[] parameters)
{
if (this.m_removeOnMethod == null)
{
this.m_removeOnMethod = new EasyMethod(this.m_maintype, "remove_" + this.Name, atts, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters));
}
return(this.m_removeOnMethod);
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(arrayReference, gen);
ArgumentsUtil.EmitLoadOwnerAndReference(index, gen);
gen.Emit(OpCodes.Ldelem, returnType);
}
