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); }