/// <summary>
/// Convert the given argument if it does not match the target type.
/// </summary>
private static void ConvertForRetIfNeeded(AstExpression arg, XTypeReference targetType)
{
var argType = arg.GetResultType();
if (!targetType.IsSame(argType))
{
if (targetType.IsChar())
{
if (argType.IsUInt16() || argType.IsByte() || argType.IsInt16())
{
Convert(arg, AstCode.Conv_U2, targetType);
}
}
else if (targetType.IsUInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Int_to_ushort, targetType);
}
}
else if (targetType.IsInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Conv_I2, targetType);
}
}
}
}
/// <summary>
/// Gets the type of stelem code to use for the given element type.
/// </summary>
public static AstCode GetStElemCode(this XTypeReference elementType)
{
if (elementType.IsByte() || elementType.IsSByte() || elementType.IsBoolean())
{
return(AstCode.Stelem_I1);
}
if (elementType.IsChar() || elementType.IsInt16() || elementType.IsUInt16())
{
return(AstCode.Stelem_I2);
}
if (elementType.IsInt32() || elementType.IsUInt32())
{
return(AstCode.Stelem_I4);
}
if (elementType.IsInt64() || elementType.IsUInt64())
{
return(AstCode.Stelem_I8);
}
if (elementType.IsFloat())
{
return(AstCode.Stelem_R4);
}
if (elementType.IsDouble())
{
return(AstCode.Stelem_R8);
}
return(AstCode.Stelem_Ref);
}
/// <summary>
/// Generate converter for the value of an Const instruction.
/// </summary>
internal static Func <object, object> ConstValueConverter(this XTypeReference elementType, bool keepUnsigned)
{
if (elementType.IsBoolean())
{
return(x => Convert.ToBoolean(x) ? 1 : 0);
}
if (elementType.IsByte())
{
if (keepUnsigned)
{
return(x => (int)Convert.ToByte(x));
}
return(x => (int)((sbyte)unchecked (Convert.ToByte(x))));
}
if (elementType.IsSByte())
{
return(x => (int)(Convert.ToSByte(x)));
}
if (elementType.IsChar())
{
return(x => (int)(Convert.ToChar(x)));
}
if (elementType.IsUInt16())
{
return(x => (int)(Convert.ToUInt16(x)));
}
if (elementType.IsInt16())
{
return(x => (int)(Convert.ToInt16(x)));
}
if (elementType.IsInt32())
{
return(x => XConvert.ToInt(x));
}
if (elementType.IsUInt32())
{
return(x => XConvert.ToInt(x)); // unchecked((int)Convert.ToUInt32(Convert.ToInt64(x) & 0xFFFFFFFF));
}
if (elementType.IsFloat())
{
return(x => Convert.ToSingle(x));
}
if (elementType.IsInt64())
{
return(x => XConvert.ToLong(x));
}
if (elementType.IsUInt64())
{
return(x => XConvert.ToLong(x)); // unchecked((long)Convert.ToInt64(x));
}
if (elementType.IsDouble())
{
return(x => Convert.ToDouble(x));
}
if (elementType.IsDexObject() && !elementType.IsVoid())
{
return(x => x);
}
throw new NotSupportedException("Unknown type for constValueConverter " + elementType);
}
/// <summary>
/// Returns the method name when converting an array to an IEnumerableT in compiler helper.
///
/// (not sure if this is the best place for this method...)
/// </summary>
public static string GetAsEnumerableTMethodName(XTypeReference sourceArrayElementType)
{
var convertMethodName = "AsObjectEnumerable";
if (sourceArrayElementType.IsPrimitive)
{
if (sourceArrayElementType.IsBoolean())
{
convertMethodName = "AsBoolEnumerable";
}
else if (sourceArrayElementType.IsByte())
{
convertMethodName = "AsByteEnumerable";
}
else if (sourceArrayElementType.IsSByte())
{
convertMethodName = "AsSByteEnumerable";
}
else if (sourceArrayElementType.IsChar())
{
convertMethodName = "AsCharEnumerable";
}
else if (sourceArrayElementType.IsInt16())
{
convertMethodName = "AsInt16Enumerable";
}
else if (sourceArrayElementType.IsUInt16())
{
convertMethodName = "AsUInt16Enumerable";
}
else if (sourceArrayElementType.IsInt32())
{
convertMethodName = "AsInt32Enumerable";
}
else if (sourceArrayElementType.IsUInt32())
{
convertMethodName = "AsUInt32Enumerable";
}
else if (sourceArrayElementType.IsInt64())
{
convertMethodName = "AsInt64Enumerable";
}
else if (sourceArrayElementType.IsFloat())
{
convertMethodName = "AsFloatEnumerable";
}
else if (sourceArrayElementType.IsDouble())
{
convertMethodName = "AsDoubleEnumerable";
}
else
{
throw new ArgumentOutOfRangeException("Unknown primitive array element type " + sourceArrayElementType);
}
}
return(convertMethodName);
}
/// <summary>
/// Convert the result of the given node to uint8/uint16 if needed.
/// </summary>
private static void ConvertIfNeeded(AstExpression node, XTypeReference valueType, AstExpression parent)
{
AstCode convCode;
if (valueType.IsByte())
{
// Convert from int to uint8
convCode = AstCode.Int_to_ubyte;
}
else if (valueType.IsUInt16())
{
// Convert from int to uint16
convCode = AstCode.Int_to_ushort;
}
else if (valueType.IsChar())
{
// Convert from int to uint16
convCode = AstCode.Conv_U2;
}
else
{
// Do not convert
return;
}
// Avoid recursion
if ((parent != null) && (parent.Code == convCode))
{
return;
}
// Copy load expression
var clone = new AstExpression(node);
// Convert node
node.Code = convCode;
node.Arguments.Clear();
node.Arguments.Add(clone);
node.Operand = null;
node.InferredType = valueType;
// keep the expected type!
node.ExpectedType = clone.ExpectedType;
clone.ExpectedType = valueType;
}
/// <summary>
/// Generate an Add opcode.
/// </summary>
private static RCode OpcodeForType(XTypeReference type, RCode[] opcodes)
{
if (type.IsInt32() || type.IsUInt32() || type.IsInt16() || type.IsUInt16() || type.IsChar() || type.IsByte() || type.IsSByte() || type.IsBoolean())
{
return(opcodes[0]);
}
if (type.IsInt64() || type.IsUInt64())
{
return(opcodes[1]);
}
if (type.IsFloat())
{
return(opcodes[2]);
}
if (type.IsDouble())
{
return(opcodes[3]);
}
XTypeDefinition typeDef;
if (type.TryResolve(out typeDef))
{
if (typeDef.IsEnum)
{
return(OpcodeForType(typeDef.GetEnumUnderlyingType(), opcodes));
}
}
throw new ArgumentException("Unsupported type " + type);
}
