/// <summary>
/// Is the given type an enum?
/// </summary>
public static bool IsEnum(this XTypeReference type)
{
type = type.GetWithoutModifiers();
XTypeDefinition typeDef;
return(type.IsEnum(out typeDef));
}
/// <summary>
/// Create code to unbox the given source value into the given type.
/// </summary>
public static RLRange Unbox(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec source, XTypeReference type, AssemblyCompiler compiler, DexTargetPackage targetPackage, IRegisterAllocator frame)
{
if (type.IsPrimitive)
{
RCode convertAfterCode;
var rUnboxed = frame.AllocateTemp(type.GetReference(targetPackage));
var unboxValueMethod = type.GetUnboxValueMethod(compiler, targetPackage, out convertAfterCode);
var first = builder.Add(sequencePoint, RCode.Invoke_static, unboxValueMethod, source);
var last = builder.Add(sequencePoint, type.MoveResult(), rUnboxed);
if (convertAfterCode != RCode.Nop)
{
last = builder.Add(sequencePoint, convertAfterCode, rUnboxed, rUnboxed);
}
return new RLRange(first, last, rUnboxed);
}
XTypeDefinition enumTypeDef;
if (type.IsEnum(out enumTypeDef))
{
var rUnboxed = frame.AllocateTemp(type.GetReference(targetPackage));
var unboxValueMethod = enumTypeDef.Methods.First(x => x.Name == NameConstants.Enum.UnboxMethodName).GetReference(targetPackage);
var first = builder.Add(sequencePoint, RCode.Invoke_static, unboxValueMethod, source);
var last = builder.Add(sequencePoint, type.MoveResult(), rUnboxed);
return new RLRange(first, last, rUnboxed);
}
if (!type.IsGenericParameter)
{
// Just cast
var checkCast = builder.Add(sequencePoint, RCode.Check_cast, type.GetReference(targetPackage), source);
return new RLRange(checkCast, source);
}
// Do nothing
var nop = builder.Add(sequencePoint, RCode.Nop);
return new RLRange(nop, source);
}
/// <summary>
/// Create code to load a value from an annotation interface.
/// </summary>
/// <returns>The register(s) holding the value</returns>
private static Register[] CreateLoadValueSequence(
ISourceLocation seqp,
MethodBody body,
XTypeReference valueType,
Register annotationReg,
MethodDefinition getter,
AssemblyCompiler compiler,
DexTargetPackage targetPackage,
out Instruction branchIfNotSet)
{
// NOTE: It would be better if we wouldn't get the values as object arrays
// but as arrays of the actual type.
// Apparently though the DexWriter will not write our attributes
// if they contain arrays not of type object[]. Therefore the
// conversion code below.
// All in all it would be much cleaner if we could emit Ast code here
// instead of RL code.
List<Register> result = new List<Register>();
// get the array.
Register regObject = body.AllocateRegister(RCategory.Temp, RType.Object);
Register regIntVal = body.AllocateRegister(RCategory.Temp, RType.Value);
body.Instructions.Add(seqp, RCode.Invoke_interface, getter, annotationReg);
body.Instructions.Add(seqp, RCode.Move_result_object, regObject);
// allocate result, initialize to default value.
if (valueType.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 (valueType.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);
}
// check if value is unset (array length 0) or null (array length 2)
body.Instructions.Add(seqp, RCode.Array_length, regIntVal, regObject);
branchIfNotSet = body.Instructions.Add(seqp, RCode.If_eqz, regIntVal);
body.Instructions.Add(seqp, RCode.Rsub_int, 1, regIntVal, regIntVal);
var branchOnNull = body.Instructions.Add(seqp, RCode.If_nez, regIntVal);
// get the (boxed) value
body.Instructions.Add(seqp, RCode.Const, 0, regIntVal);
// convert to target type.
if (valueType.IsArray)
{
Register regTmp = body.AllocateRegister(RCategory.Temp, RType.Object);
Register regType = body.AllocateRegister(RCategory.Temp, RType.Object);
var helper = compiler.GetDot42InternalType(InternalConstants.CompilerHelperName);
var convertArray = helper.Resolve().Methods.First(p => p.Name == "ConvertArray" && p.Parameters.Count == 2)
.GetReference(targetPackage);
var underlying = valueType.ElementType.GetReference(targetPackage);
body.Instructions.Add(seqp, RCode.Aget_object, regTmp, regObject, regIntVal);
body.Instructions.Add(seqp, RCode.Const_class, underlying, regType);
body.Instructions.Add(seqp, RCode.Invoke_static, convertArray, regTmp, regType);
body.Instructions.Add(seqp, RCode.Move_result_object, result[0]);
body.Instructions.Add(seqp, RCode.Check_cast, valueType.GetReference(targetPackage), result[0]);
}
else if (valueType.IsEnum())
{
Register regTmp = body.AllocateRegister(RCategory.Temp, RType.Object);
Register regType = body.AllocateRegister(RCategory.Temp, RType.Object);
var getFromObject = compiler.GetDot42InternalType("Enum").Resolve()
.Methods.Single(p=>p.Name == "GetFromObject")
.GetReference(targetPackage);
body.Instructions.Add(seqp, RCode.Aget_object, regTmp, regObject, regIntVal);
body.Instructions.Add(seqp, RCode.Const_class, valueType.GetReference(targetPackage), regType);
body.Instructions.Add(seqp, RCode.Invoke_static, getFromObject, regType, regTmp);
body.Instructions.Add(seqp, valueType.MoveResult(), result[0]);
body.Instructions.Add(seqp, RCode.Check_cast, valueType.GetReference(targetPackage), result[0]);
}
else if(!valueType.IsPrimitive)
{
body.Instructions.Add(seqp, RCode.Aget_object, result[0], regObject, regIntVal);
body.Instructions.Add(seqp, RCode.Check_cast, valueType.GetReference(targetPackage), result[0]);
}
else
{
Register regTmp = body.AllocateRegister(RCategory.Temp, RType.Object);
// unbox and store
RCode afterConvert;
var unbox = valueType.GetUnboxValueMethod(compiler, targetPackage, out afterConvert);
body.Instructions.Add(seqp, RCode.Aget_object, regTmp, regObject, regIntVal);
body.Instructions.Add(seqp, RCode.Invoke_static, unbox, regTmp);
body.Instructions.Add(seqp, valueType.MoveResult(), result[0]);
if (afterConvert != RCode.Nop)
{
body.Instructions.Add(seqp, afterConvert, result[0], result[0]);
}
}
// nop will be removed at some stage later.
var nop = body.Instructions.Add(seqp, RCode.Nop);
branchOnNull.Operand = nop;
return result.ToArray();
}
/// <summary>
/// Is the given type an enum?
/// </summary>
public static bool IsEnum(this XTypeReference type)
{
XTypeDefinition typeDef;
return(type.IsEnum(out typeDef));
}
/// <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();
}
