public static void EmitLoadLocal(YaleIlGenerator ilg, int index)
{
Debug.Assert(index >= 0, "Invalid index");
if (index >= 0 & index <= 3)
{
switch (index)
{
case 0:
ilg.Emit(OpCodes.Ldloc_0);
break;
case 1:
ilg.Emit(OpCodes.Ldloc_1);
break;
case 2:
ilg.Emit(OpCodes.Ldloc_2);
break;
case 3:
ilg.Emit(OpCodes.Ldloc_3);
break;
}
}
else
{
Debug.Assert(index < 256, "local index too large");
ilg.Emit(OpCodes.Ldloc_S, Convert.ToByte(index));
}
}
public static void EmitLoadLocalAddress(YaleIlGenerator ilg, int index)
{
Debug.Assert(index >= 0, "Invalid index");
if (index <= byte.MaxValue)
{
ilg.Emit(OpCodes.Ldloca_S, Convert.ToByte(index));
}
else
{
ilg.Emit(OpCodes.Ldloca, index);
}
}
private static bool ImplicitConvertToReferenceType(Type sourceType, Type destinationType, YaleIlGenerator ilGenerator)
{
if (destinationType.IsValueType)
{
return(false);
}
if (ReferenceEquals(sourceType, typeof(Null)))
{
// Null is always convertible to a reference type
return(true);
}
if (destinationType.IsAssignableFrom(sourceType) == false)
{
return(false);
}
if (sourceType.IsValueType)
{
ilGenerator?.Emit(OpCodes.Box, sourceType);
}
return(true);
}
private static bool EmitOverloadedImplicitConvert(Type sourceType, Type destinationType, YaleIlGenerator ilGenerator)
{
// Look for an implicit operator on the destination type
var methodInfo = Utility.GetSimpleOverloadedOperator("Implicit", sourceType, destinationType);
if (methodInfo == null)
{
return(false);
}
ilGenerator?.Emit(OpCodes.Call, methodInfo);
return(true);
}
public static void EmitArrayStore(YaleIlGenerator ilg, Type elementType)
{
var typeCode = Type.GetTypeCode(elementType);
switch (typeCode)
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Boolean:
ilg.Emit(OpCodes.Stelem_I1);
break;
case TypeCode.Int16:
case TypeCode.UInt16:
ilg.Emit(OpCodes.Stelem_I2);
break;
case TypeCode.Int32:
case TypeCode.UInt32:
ilg.Emit(OpCodes.Stelem_I4);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
ilg.Emit(OpCodes.Stelem_I8);
break;
case TypeCode.Single:
ilg.Emit(OpCodes.Stelem_R4);
break;
case TypeCode.Double:
ilg.Emit(OpCodes.Stelem_R8);
break;
case TypeCode.Object:
case TypeCode.String:
ilg.Emit(OpCodes.Stelem_Ref);
break;
default:
// Must be a non-primitive value type
ilg.Emit(OpCodes.Stelem, elementType);
break;
}
}
private static void EmitConvert(YaleIlGenerator ilg, OpCode convertOpcode)
{
ilg?.Emit(convertOpcode);
}
