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);
}
public void EmitGetHelper(Operand op, Type desiredType, bool allowExplicitConversion)
{
if (desiredType.IsByRef)
{
if (op.Type != desiredType.GetElementType())
{
throw new InvalidOperationException("Argument passed by reference must have exactly the same type as the formal argument");
}
op.EmitAddressOf(this);
return;
}
if ((object)op == null)
{
if (desiredType.IsValueType)
{
throw new ArgumentNullException("op");
}
il.Emit(OpCodes.Ldnull);
return;
}
op.EmitGet(this);
Convert(op, desiredType, allowExplicitConversion);
}
internal void EmitGetHelper(Operand op, Type desiredType, bool allowExplicitConversion)
{
if (desiredType.IsByRef)
{
if (op.Type != desiredType.GetElementType())
{
throw new InvalidOperationException(Properties.Messages.ErrByRefTypeMismatch);
}
op.EmitAddressOf(this);
return;
}
if ((object)op == null)
{
if (desiredType.IsValueType)
{
throw new ArgumentNullException("op");
}
il.Emit(OpCodes.Ldnull);
return;
}
op.EmitGet(this);
Convert(op, desiredType, allowExplicitConversion);
}
void EmitArg(CodeGen g, int index, Operand arg)
{
if (_appliedSignature[index].IsByRef)
{
arg.EmitAddressOf(g);
return;
}
g.EmitGetHelper(arg, _appliedSignature[index], _conversions[index], @from: _paramsSignature[index]);
}
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 void InitObj(Operand target)
{
if ((object)target == null)
{
throw new ArgumentNullException("target");
}
BeforeStatement();
target.EmitAddressOf(this);
il.Emit(OpCodes.Initobj, target.Type);
}
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 EmitArg(CodeGen g, int index, Operand arg)
{
if (appliedSignature[index].IsByRef)
{
arg.EmitAddressOf(g);
return;
}
if ((object)arg == null)
{
g.IL.Emit(OpCodes.Ldnull);
}
else
{
arg.EmitGet(g);
}
conversions[index].Emit(g, paramsSignature[index], appliedSignature[index]);
}
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);
}
}
protected internal override void EmitAddressOf(CodeGen g)
{
OperandExtensions.SetLeakedState(this, false);
_operand.EmitAddressOf(g);
}
public void InitObj(Operand target)
{
if ((object)target == null)
throw new ArgumentNullException("target");
BeforeStatement();
target.EmitAddressOf(this);
il.Emit(OpCodes.Initobj, target.Type);
}
internal override void EmitAddressOf(CodeGen g)
{
op.EmitAddressOf(g);
}
public override void EmitAddressOf(CodeGen g)
{
op.EmitAddressOf(g);
}
internal void EmitGetHelper(Operand op, Type desiredType, bool allowExplicitConversion)
{
if (desiredType.IsByRef)
{
if (op.Type != desiredType.GetElementType())
throw new InvalidOperationException(Properties.Messages.ErrByRefTypeMismatch);
op.EmitAddressOf(this);
return;
}
if ((object)op == null)
{
if (desiredType.IsValueType)
throw new ArgumentNullException("op");
il.Emit(OpCodes.Ldnull);
return;
}
op.EmitGet(this);
Convert(op, desiredType, allowExplicitConversion);
}
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 EmitArg(CodeGen g, int index, Operand arg)
{
if (appliedSignature[index].IsByRef)
{
arg.EmitAddressOf(g);
return;
}
if ((object)arg == null)
g.IL.Emit(OpCodes.Ldnull);
else
arg.EmitGet(g);
conversions[index].Emit(g, paramsSignature[index], appliedSignature[index]);
}
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);
}