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