public override void Emit(IEasyMember member, ILGenerator gen)
{
this._right.Emit(member, gen);
if (this._fromType != this._target)
{
if (this._fromType.IsByRef)
{
throw new NotSupportedException("Cannot convert from ByRef types");
}
if (this._target.IsByRef)
{
throw new NotSupportedException("Cannot convert to ByRef types");
}
if (this._target.IsValueType)
{
if (this._fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types at the moment");
}
gen.Emit(OpCodes.Unbox, this._target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, this._target);
}
else if (this._fromType.IsValueType)
{
gen.Emit(OpCodes.Box, this._fromType);
this.EmitCastIfNeeded(typeof(object), this._target, gen);
}
else
{
this.EmitCastIfNeeded(this._fromType, this._target, gen);
}
}
}
public 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.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 Push(IlBuilder builder)
{
if (Index <= 3)
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldloc_" + Index));
}
else
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldloc"), Index);
}
}
private ParsedOpCode ParseOpcode(string token)
{
token = token.ToUpper().Trim();
if (!token.StartsWith("OP"))
{
token = $"OP_{token}";
}
var code = OpCodeUtil.FromString(token);
return(new ParsedOpCode(code));
}
public override void Store(IlBuilder builder, CodeValue val)
{
builder.PushValue(val);
if (Index <= 3)
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stloc_" + Index));
}
else
{
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stloc"), Index);
}
}
public override void Push(IlBuilder builder)
{
if (_indexerCall == null)
{
builder.PushValue(_array);
builder.PushValue(_index);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Ldelem_" + Type.OpName));
}
else
{
_indexerCall.Emit(builder);
}
}
public override void Store(IlBuilder builder, CodeValue source)
{
if (_indexerCall == null)
{
builder.PushValue(_array);
builder.PushValue(_index);
builder.PushValue(source);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stelem_" + Type.OpName));
}
else
{
throw new NotImplementedException();
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
_right.Emit(member, gen);
if (_fromType == _target)
{
return;
}
if (_fromType.IsByRef)
{
throw new NotSupportedException("Cannot convert from ByRef types");
}
if (_target.IsByRef)
{
throw new NotSupportedException("Cannot convert to ByRef types");
}
if (_target.IsValueType)
{
if (_fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types at the moment");
}
else
{
// Unbox conversion
// Assumes fromType is a boxed value
gen.Emit(OpCodes.Unbox, _target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, _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(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 EmitByRef(ILGenerator gen)
{
var elementType = type.GetElementType();
if (IsPrimitiveOrClass(elementType))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, elementType);
OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, elementType);
}
else if (elementType.GetTypeInfo().IsGenericParameter || elementType.GetTypeInfo().IsValueType)
{
gen.Emit(OpCodes.Initobj, elementType);
}
else
{
throw new ProxyGenerationException("Can't emit default value for reference of type " + elementType);
}
}
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 override void Emit(IlBuilder builder)
{
base.Emit(builder);
builder.PushValue(_rank);
builder.EmitOpCode(OpCodes.Newarr, _typeof.TypeOf.Name);
if (_entries == null)
{
return;
}
for (int i = 0; i < _entries.Length; i++)
{
builder.EmitOpCode(OpCodes.Dup);
builder.PushValue(new CodeValue(BasicType.Int32, i));
builder.PushValue(_entries[i]);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Stelem_" + _typeof.TypeOf.OpName));
}
}
public override void Emit(IMemberEmitter member, ILGenerator gen)
{
// TODO: check if this can be simplified by using more of OpCodeUtil and other existing types
if (IsPrimitiveOrClass(type))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, type);
}
else if (type.IsValueType || type.IsGenericParameter)
{
// TODO: handle decimal explicitly
var local = gen.DeclareLocal(type);
gen.Emit(OpCodes.Ldloca_S, local);
gen.Emit(OpCodes.Initobj, type);
gen.Emit(OpCodes.Ldloc, local);
}
else if (type.IsByRef)
{
EmitByRef(gen);
}
else
{
throw new ProxyGenerationException("Can't emit default value for type " + type);
}
}
public override void StoreReference(ILGenerator gen)
{
OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, Type);
}
// TODO: Better name
public override void LoadReference(ILGenerator gen)
{
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type);
}
public override void LoadReference(ILGenerator gen)
{
OpCodeUtil.EmitLoadOpCodeForConstantValue(gen, _value);
}
public override void Store(IlBuilder builder, CodeValue val)
{
builder.PushValue(val);
builder.EmitOpCode(OpCodeUtil.GetOpcode("Starg"), Index);
}
