/// <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>
/// Reverses the code, taking account float/double NaN comparisons
/// </summary>
private static AstCode ReverseCode(AstCode code, XTypeReference type)
{
bool isFlt = type.IsDouble() || type.IsFloat();
if (!isFlt)
return code.Reverse();
switch (code)
{
case AstCode.Ceq:
return AstCode.Cne;
case AstCode.Cne:
return AstCode.Ceq;
case AstCode.Cle:
return AstCode.Cgt_Un;
case AstCode.Cle_Un:
return AstCode.Cgt;
case AstCode.Clt:
return AstCode.Cge_Un;
case AstCode.Clt_Un:
return AstCode.Cge;
case AstCode.Cgt:
return AstCode.Cle_Un;
case AstCode.Cgt_Un:
return AstCode.Cle;
case AstCode.Cge:
return AstCode.Clt_Un;
case AstCode.Cge_Un:
return AstCode.Clt;
default:
throw new ArgumentOutOfRangeException("code", code.ToString());
}
}
/// <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);
}
/// <summary>
/// Create code to initialize a value from an attribute.
/// </summary>
/// <returns>The register(s) holding the value</returns>
private static Register[] CreateInitializeValueInstructions(ISourceLocation seqp, MethodBody body, XTypeReference targetType, CustomAttributeArgument value, AssemblyCompiler compiler, DexTargetPackage targetPackage)
{
List<Register> result = new List<Register>();
// allocate result, initialize to default value.
if (targetType.IsWide())
{
Tuple<Register, Register> regs = body.AllocateWideRegister(RCategory.Temp);
//body.Instructions.Add(seqp, RCode.Const_wide, 0, regs.Item1);
result.Add(regs.Item1);
result.Add(regs.Item2);
}
else if (targetType.IsPrimitive)
{
Register reg = body.AllocateRegister(RCategory.Temp, RType.Value);
//body.Instructions.Add(seqp, RCode.Const, 0, reg);
result.Add(reg);
}
else // object
{
Register reg = body.AllocateRegister(RCategory.Temp, RType.Object);
//body.Instructions.Add(seqp, RCode.Const, 0, reg);
result.Add(reg);
}
// load data
if (value.Value == null) // must be a reference type
{
body.Instructions.Add(seqp, RCode.Const, 0, result[0]);
body.Instructions.Add(seqp, RCode.Check_cast, targetType.GetReference(targetPackage), result[0]);
return result.ToArray();
}
var valueType = XBuilder.AsTypeReference(compiler.Module, value.Type);
if (value.Value is CustomAttributeArgument)
{
// this happens if a type conversion is neccessary
var nestedValue = (CustomAttributeArgument)value.Value;
valueType = XBuilder.AsTypeReference(compiler.Module, nestedValue.Type);
var rOrigValue = CreateInitializeValueInstructions(seqp, body, valueType, nestedValue, compiler, targetPackage);
if (!nestedValue.Type.IsPrimitive)
{
body.Instructions.Add(seqp, RCode.Move_object, result[0], rOrigValue[0]);
body.Instructions.Add(seqp, RCode.Check_cast, targetType.GetReference(targetPackage), result[0]);
}
else if(!targetType.IsPrimitive)
{
body.Instructions.Add(seqp, RCode.Invoke_static, valueType.GetBoxValueOfMethod(), rOrigValue);
body.Instructions.Add(seqp, RCode.Move_result_object, result[0]);
body.Instructions.Add(seqp, RCode.Check_cast, targetType.GetReference(targetPackage), result[0]);
}
else
{
throw new Exception(string.Format("type converstion in attribute {0}=>{1} not yet supported", valueType.FullName, targetType.FullName));
}
}
else if (valueType.IsArray)
{
var array = (CustomAttributeArgument[])value.Value;
var elementType = valueType.ElementType;
Register rIndex = body.AllocateRegister(RCategory.Temp, RType.Value);
body.Instructions.Add(seqp, RCode.Const, array.Length, rIndex);
body.Instructions.Add(seqp, RCode.New_array, valueType.GetReference(targetPackage), result[0], rIndex);
// iterate through each value
for (int i = 0; i < array.Length; i++)
{
Register rLoaded = CreateInitializeValueInstructions(seqp, body, elementType, array[i], compiler, targetPackage)[0];
body.Instructions.Add(seqp, RCode.Const, i, rIndex);
body.Instructions.Add(seqp, valueType.APut(), rLoaded, result[0], rIndex);
}
}
else if (targetType.IsEnum())
{
var enumClass = (targetType.IsEnum()? targetType:valueType).GetReference(targetPackage) ;
Register rEnumClass = body.AllocateRegister(RCategory.Temp, RType.Object);
body.Instructions.Add(seqp, RCode.Const_class, enumClass, rEnumClass);
long lVal = Convert.ToInt64(value.Value);
if (lVal <= int.MaxValue && lVal >= int.MinValue)
{
Register regTmp = body.AllocateRegister(RCategory.Temp, RType.Value);
body.Instructions.Add(seqp, RCode.Const, (int)lVal, regTmp);
var get = compiler.GetDot42InternalType("Enum").Resolve()
.Methods.Single(p => p.Name == "Get" && p.Parameters.Count == 2 && !p.Parameters[1].ParameterType.IsWide())
.GetReference(targetPackage);
body.Instructions.Add(seqp, RCode.Invoke_static, get, rEnumClass, regTmp);
body.Instructions.Add(seqp, targetType.MoveResult(), result[0]);
}
else
{
var regTmp = body.AllocateWideRegister(RCategory.Temp);
body.Instructions.Add(seqp, RCode.Const, (long)lVal, regTmp.Item1);
var get = compiler.GetDot42InternalType("Enum").Resolve()
.Methods.Single(p => p.Name == "Get" && p.Parameters.Count == 2 && p.Parameters[1].ParameterType.IsWide())
.GetReference(targetPackage);
body.Instructions.Add(seqp, RCode.Invoke_static, get, rEnumClass, regTmp.Item1);
body.Instructions.Add(seqp, targetType.MoveResult(), result[0]);
}
body.Instructions.Add(seqp, RCode.Check_cast, targetType.GetReference(targetPackage), result[0]);
}
else if (valueType.IsSystemString())
{
body.Instructions.Add(seqp, RCode.Const_string, (string)value.Value, result[0]);
}
else if (valueType.IsSystemType())
{
var type = XBuilder.AsTypeReference(compiler.Module, (TypeReference)value.Value);
// TODO: this might not work with typeof(void) on ART runtime.
body.Instructions.Add(seqp, RCode.Const_class, type.GetReference(targetPackage), result[0]);
}
else if (!valueType.IsPrimitive)
{
// can this happen?
throw new Exception("invalid value type in attribute: " + targetType.FullName);
}
else
{
if (targetType.IsSystemObject())
{
// can this happen? or is this always handled above?
// boxing required.
var rUnboxed = CreateInitializeValueInstructions(seqp, body, valueType, value, compiler, targetPackage);
body.Instructions.Add(seqp, RCode.Invoke_static, valueType.GetBoxValueOfMethod(), rUnboxed);
body.Instructions.Add(seqp, RCode.Move_result_object, result[0]);
}
else if(targetType.IsDouble())
{
body.Instructions.Add(seqp, RCode.Const_wide, Convert.ToDouble(value.Value), result[0]);
}
else if (targetType.IsWide() && valueType.IsUInt64())
{
body.Instructions.Add(seqp, RCode.Const_wide, (long)Convert.ToUInt64(value.Value), result[0]);
}
else if (targetType.IsWide())
{
body.Instructions.Add(seqp, RCode.Const_wide, Convert.ToInt64(value.Value), result[0]);
}
else if (targetType.IsFloat())
{
body.Instructions.Add(seqp, RCode.Const, Convert.ToSingle(value.Value), result[0]);
}
else
{
body.Instructions.Add(seqp, RCode.Const, (int)Convert.ToInt64(value.Value), result[0]);
}
}
return result.ToArray();
}
