|
public abstract GetReturnType ( ITypeMapper typeMapper ) : |
||
| typeMapper | ITypeMapper | |
| Результат | ||
protected internal void EmitCallHelper(MethodBase mth, Operand target)
{
MethodInfo mi = mth as MethodInfo;
if (mi != null)
{
bool suppressVirtual = ((object)target != null && target.SuppressVirtual) || mi.IsStatic || (((object)target != null) &&
(target.GetReturnType(TypeMapper).IsValueType || target.GetReturnType(TypeMapper).IsArray) && !mi.IsVirtual);
if (!suppressVirtual && (object)target != null && target.GetReturnType(TypeMapper).IsValueType&& mi.IsVirtual)
{
IL.Emit(OpCodes.Constrained, target.GetReturnType(TypeMapper));
}
//Console.WriteLine("Emitting " + mth + ", using " + (suppressVirtual ? "call" : "callvirt"));
IL.Emit(suppressVirtual ? OpCodes.Call : OpCodes.Callvirt, mi);
return;
}
ConstructorInfo ci = mth as ConstructorInfo;
if (ci != null)
{
IL.Emit(OpCodes.Call, ci);
return;
}
throw new ArgumentException(Properties.Messages.ErrInvalidMethodBase, nameof(mth));
}
internal void EmitGetHelper(Operand op, Type desiredType, bool allowExplicitConversion)
{
if (desiredType.IsByRef)
{
if (op.GetReturnType(TypeMapper) != desiredType.GetElementType())
{
throw new InvalidOperationException(Messages.ErrByRefTypeMismatch);
}
op.EmitAddressOf(this);
return;
}
if ((object)op == null)
{
if (desiredType.IsValueType)
{
throw new ArgumentNullException(nameof(op));
}
IL.Emit(OpCodes.Ldnull);
return;
}
op.EmitGet(this);
Convert(op, desiredType, allowExplicitConversion);
}
void EmitGetHelper_Conversion(Operand op, Type desiredType, Conversion conv, Type from = null)
{
if (conv.RequiresAddress)
{
if (ReferenceEquals(op, null))
{
throw new ArgumentException("Conversion from nullref to " + desiredType.Name + " is impossible; for nullables variable it's required to load address.");
}
op.EmitAddressOf(this);
}
else if (ReferenceEquals(op, null))
{
IL.Emit(OpCodes.Ldnull);
}
else
{
op.EmitGet(this);
}
if (from == null)
{
from = (object)op == null ? null : op.GetReturnType(TypeMapper);
}
conv.Emit(this, from, desiredType);
}
protected internal static Type GetType(Operand op, ITypeMapper typeMapper)
{
if ((object)op == null)
{
return(null);
}
return(op.GetReturnType(typeMapper));
}
void DoInvoke(Operand invocation)
{
BeforeStatement();
invocation.EmitGet(this);
if (!Helpers.AreTypesEqual(invocation.GetReturnType(TypeMapper), typeof(void), TypeMapper))
{
IL.Emit(OpCodes.Pop);
}
}
public IfBlock(Operand condition, ITypeMapper typeMapper)
{
if (!Helpers.AreTypesEqual(condition.GetReturnType(typeMapper), typeof(bool), typeMapper))
{
_condition = condition.IsTrue();
}
else
{
_condition = condition;
}
}
public LoopBlock(IStatement init, Operand test, IStatement iter, ITypeMapper typeMapper)
{
_init = init;
_test = test;
_iter = iter;
if (!Helpers.AreTypesEqual(test.GetReturnType(typeMapper), typeof(bool), typeMapper))
{
test = test.IsTrue();
}
}
public void InitObj(Operand target)
{
if ((object)target == null)
{
throw new ArgumentNullException(nameof(target));
}
BeforeStatement();
target.EmitAddressOf(this);
IL.Emit(OpCodes.Initobj, target.GetReturnType(TypeMapper));
}
public SwitchBlock(Operand expression, ITypeMapper typeMapper)
{
_typeMapper = typeMapper;
_strCmp = typeMapper.MapType(typeof(string)).GetMethod(
"Equals",
BindingFlags.Public | BindingFlags.Static,
null,
new Type[] { typeMapper.MapType(typeof(string)), typeMapper.MapType(typeof(string)) },
null);
_expression = expression;
Type exprType = expression.GetReturnType(typeMapper);
foreach (var t in _validTypes)
{
Type mapped = typeMapper.MapType(t);
if (mapped == exprType)
{
_govType = mapped;
break;
}
}
if (_govType == null)
{
if (exprType.IsEnum)
{
_govType = Helpers.GetEnumEnderlyingType(exprType);
}
else
{
// if a single implicit coversion from expression to one of the valid types exists, it's ok
foreach (System.Type t in _validTypes)
{
Conversion tmp = Conversion.GetImplicit(expression, typeMapper.MapType(t), false, typeMapper);
if (tmp.IsValid)
{
if (_conv == null)
{
_conv = tmp;
_govType = typeMapper.MapType(t);
//if (_govType==expression.)
}
else
{
throw new AmbiguousMatchException(Messages.ErrAmbiguousSwitchExpression);
}
}
}
}
}
}
void EmitGetHelper_Ref(Operand op, Type desiredType)
{
if (ReferenceEquals(op, null))
{
throw new ArgumentException("Ref argument can't be null, expected " + desiredType.Name);
}
if (op.GetReturnType(TypeMapper) != desiredType.GetElementType())
{
throw new InvalidOperationException(Properties.Messages.ErrByRefTypeMismatch);
}
op.EmitAddressOf(this);
}
protected internal override void EmitSet(CodeGen g, Operand value, bool allowExplicitConversion)
{
OperandExtensions.SetLeakedState(this, false);
CheckScope(g);
if (_t == null)
{
_t = value.GetReturnType(g.TypeMapper);
}
if (_var == null)
{
_var = g.IL.DeclareLocal(_t);
}
Type nullableUnderlyingType = Helpers.GetNullableUnderlyingType(_t);
if (ReferenceEquals(value, null))
{
if (nullableUnderlyingType != null)
{
g.InitObj(this);
return;
}
}
else if (nullableUnderlyingType == value.GetReturnType(g.TypeMapper))
{
EmitAddressOf(g);
g.EmitGetHelper(value, nullableUnderlyingType, false);
ConstructorInfo ctor = _t.GetConstructor(new [] { nullableUnderlyingType });
g.IL.Emit(OpCodes.Call, ctor);
return;
}
g.EmitGetHelper(value, _t, allowExplicitConversion);
EmitSetFromStack(g);
}
protected override void BeginImpl()
{
_lbDecision = G.IL.DefineLabel();
_lbDefault = _lbEnd = G.IL.DefineLabel();
_expression.EmitGet(G);
if (_conv != null)
{
_conv.Emit(G, _expression.GetReturnType(G.TypeMapper), _govType);
}
_exp = G.IL.DeclareLocal(_govType);
G.IL.Emit(OpCodes.Stloc, _exp);
G.IL.Emit(OpCodes.Br, _lbDecision);
G._reachable = false;
}
public void InitializeCondition(Operand test)
{
if (ReferenceEquals(test, null))
{
throw new ArgumentNullException(nameof(test));
}
if (!ReferenceEquals(_test, null))
{
throw new InvalidOperationException("Loop condition has been already initialized");
}
if (!Helpers.AreTypesEqual(test.GetReturnType(_typeMapper), typeof(bool), _typeMapper))
{
test = test.IsTrue();
}
_test = test;
}
internal override void EmitSet(CodeGen g, Operand value, bool allowExplicitConversion)
{
CheckScope(g);
if (_t == null)
{
_t = value.GetReturnType(g.TypeMapper);
}
if (_var == null)
{
_var = g.IL.DeclareLocal(_t);
}
g.EmitGetHelper(value, _t, allowExplicitConversion);
g.IL.Emit(OpCodes.Stloc, _var);
}
protected override void BeginImpl()
{
G.BeforeStatement();
_enumerator = G.Local();
_lbLoop = G.IL.DefineLabel();
_lbTest = G.IL.DefineLabel();
if (Helpers.IsAssignableFrom(typeof(IEnumerable), _collection.GetReturnType(G.TypeMapper), _typeMapper))
{
_collection = _collection.Cast(_typeMapper.MapType(typeof(IEnumerable)));
}
G.Assign(_enumerator, _collection.Invoke("GetEnumerator", _typeMapper));
G.IL.Emit(OpCodes.Br, _lbTest);
G.IL.MarkLabel(_lbLoop);
Element = G.Local(_elementType);
G.Assign(Element, _enumerator.Property("Current", _typeMapper), true);
}
public void InitObj(Operand target)
{
if ((object)target == null)
{
throw new ArgumentNullException(nameof(target));
}
BeforeStatement();
Type type = target.GetReturnType(TypeMapper);
if (type.IsValueType)
{
target.EmitAddressOf(this);
IL.Emit(OpCodes.Initobj, type);
}
else
{
Assign(target, null);
}
}
public void UnsubscribeEvent(Operand target, string eventName, Operand handler)
{
if ((object)target == null)
{
throw new ArgumentNullException(nameof(target));
}
if ((object)handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
IMemberInfo evt = TypeMapper.TypeInfo.FindEvent(target.GetReturnType(TypeMapper), eventName, target.IsStaticTarget);
MethodInfo mi = ((EventInfo)evt.Member).GetRemoveMethod();
if (!target.IsStaticTarget)
{
target.EmitGet(this);
}
handler.EmitGet(this);
EmitCallHelper(mi, target);
}
/// <summary>
/// Allows evaluation of <see cref="StaticFactory.Invoke"/>, <see cref="ExpressionFactory.New"/> and others. The result of the evaluation is discarded.
/// </summary>
/// <remarks>E.g. if you already have `exp.New(typeof(MyClass))` part you may wrap it with Eval: g.Eval(myExp).</remarks>
public void Eval(Operand operand)
{
BeforeStatement();
operand.EmitGet(this);
if (!Helpers.AreTypesEqual(operand.GetReturnType(TypeMapper), typeof(void), TypeMapper))
{
if (!_leaveNextReturnOnStack)
{
IL.Emit(OpCodes.Pop);
}
else
{
_leaveNextReturnOnStack = false;
}
}
else if (_leaveNextReturnOnStack)
{
throw new InvalidOperationException(nameof(LeaveNextReturnOnStack) + " called but operand " + operand.ToString() + " doesn't return a value");
}
}
internal void EmitGetHelper(Operand op, Type desiredType, Conversion conv, Type from = null)
{
if (desiredType.IsPrimitive && op.ConstantValue != null)
{
var opType = op.GetReturnType(TypeMapper);
if (opType.IsPrimitive && opType != desiredType)
{
// hot swap literals
var c = op.ConstantValue;
object converted = null;
try
{
converted = Convert.ChangeType(c, System.Type.GetType(desiredType.FullName));
}
catch
{
}
if (converted != null)
{
Operand.FromObject(converted).EmitGet(this);
return;
}
}
}
if (conv == null)
{
EmitGetHelper(op, desiredType, false);
return;
}
EmitGetHelper_Conversion(op, desiredType.IsByRef ? desiredType.GetElementType() : desiredType, conv, from);
if (desiredType.IsByRef)
{
EmitGetHelper_Ref(op, desiredType);
}
}
public override Type GetReturnType(ITypeMapper typeMapper)
{
OperandExtensions.SetLeakedState(this, false);
return(_operand.GetReturnType(typeMapper));
}
protected internal static Type GetType(Operand op, ITypeMapper typeMapper)
{
if ((object)op == null)
return null;
return op.GetReturnType(typeMapper);
}
void EmitGetHelper_Ref(Operand op, Type desiredType)
{
if (ReferenceEquals(op, null))
throw new ArgumentException("Ref argument can't be null, expected " + desiredType.Name);
if (op.GetReturnType(TypeMapper) != desiredType.GetElementType())
throw new InvalidOperationException(Properties.Messages.ErrByRefTypeMismatch);
op.EmitAddressOf(this);
}
void EmitGetHelper_Conversion(Operand op, Type desiredType, Conversion conv, Type from = null)
{
if (conv.RequiresAddress)
{
if (ReferenceEquals(op, null))
throw new ArgumentException("Conversion from nullref to " + desiredType.Name + " is impossible; for nullables variable it's required to load address.");
op.EmitAddressOf(this);
}
else if (ReferenceEquals(op, null))
IL.Emit(OpCodes.Ldnull);
else
op.EmitGet(this);
if (from == null)
from = (object)op == null ? null : op.GetReturnType(TypeMapper);
conv.Emit(this, from, desiredType);
}
protected internal void EmitCallHelper(MethodBase mth, Operand target)
{
MethodInfo mi = mth as MethodInfo;
if (mi != null)
{
bool suppressVirtual = ((object)target != null && target.SuppressVirtual) || mi.IsStatic || (((object)target != null)
&& (target.GetReturnType(TypeMapper).IsValueType|| target.GetReturnType(TypeMapper).IsArray) && !mi.IsVirtual);
if (!suppressVirtual && (object)target != null && target.GetReturnType(TypeMapper).IsValueType && mi.IsVirtual)
{
IL.Emit(OpCodes.Constrained, target.GetReturnType(TypeMapper));
}
//Console.WriteLine("Emitting " + mth + ", using " + (suppressVirtual ? "call" : "callvirt"));
IL.Emit(suppressVirtual ? OpCodes.Call : OpCodes.Callvirt, mi);
return;
}
ConstructorInfo ci = mth as ConstructorInfo;
if (ci != null)
{
IL.Emit(OpCodes.Call, ci);
return;
}
throw new ArgumentException(Properties.Messages.ErrInvalidMethodBase, nameof(mth));
}
internal void Convert(Operand op, Type to, bool allowExplicit)
{
Conversion conv = allowExplicit ? Conversion.GetExplicit(op, to, false, TypeMapper) : Conversion.GetImplicit(op, to, false, TypeMapper);
conv.Emit(this, (object)op == null ? null : op.GetReturnType(TypeMapper), to);
}
public override Type GetReturnType(ITypeMapper typeMapper) => _op.GetReturnType(typeMapper).MakeByRefType();
protected internal override void EmitSet(CodeGen g, Operand value, bool allowExplicitConversion)
{
OperandExtensions.SetLeakedState(this, false);
CheckScope(g);
if (_t == null)
_t = value.GetReturnType(g.TypeMapper);
if (_var == null)
_var = g.IL.DeclareLocal(_t);
Type nullableUnderlyingType = Helpers.GetNullableUnderlyingType(_t);
if (ReferenceEquals(value, null))
{
if (nullableUnderlyingType != null)
{
g.InitObj(this);
return;
}
}
else if (nullableUnderlyingType == value.GetReturnType(g.TypeMapper))
{
EmitAddressOf(g);
g.EmitGetHelper(value, nullableUnderlyingType, false);
ConstructorInfo ctor = _t.GetConstructor(new [] { nullableUnderlyingType});
g.IL.Emit(OpCodes.Call, ctor);
return;
}
g.EmitGetHelper(value, _t, allowExplicitConversion);
EmitSetFromStack(g);
}
