/// <summary>
/// Implemented all fields and methods.
/// </summary>
protected override void CreateMembers(DexTargetPackage targetPackage)
{
// Create normal members
base.CreateMembers(targetPackage);
if(!Type.IsAbstract)
{
// Create annotation interface and attribute build methods
mapping = AttributeAnnotationInstanceBuilder.CreateMapping(null, Compiler, targetPackage, Type, Class);
Compiler.Record(Type, mapping);
}
}
private static MethodDefinition CreateFactoryMethod(AssemblyCompiler compiler, DexTargetPackage targetPackage, CustomAttribute attribute, AttributeAnnotationMapping mapping)
{
var targetClass = mapping.AttributeClass; // is this really the right place for the factory methods?
ISourceLocation seqp = null;
var attributeTypeDef = attribute.AttributeType.Resolve();
// create method
string methodName = CreateAttributeFactoryMethodName(targetClass);
MethodDefinition method = new MethodDefinition(targetClass, methodName, new Prototype(mapping.AttributeClass));
method.AccessFlags = AccessFlags.Public | AccessFlags.Static | AccessFlags.Synthetic;
targetClass.Methods.Add(method);
// create method body
MethodBody body = new MethodBody(null);
// Allocate attribute
Register attributeReg = body.AllocateRegister(RCategory.Temp, RType.Object);
body.Instructions.Add(seqp, RCode.New_instance, mapping.AttributeClass, attributeReg);
// collect ctor arguments
List<Register> ctorArgRegs = new List<Register>() { attributeReg };
foreach (var p in attribute.ConstructorArguments)
{
XTypeReference xType = XBuilder.AsTypeReference(compiler.Module, p.Type);
Register[] valueRegs = CreateInitializeValueInstructions(seqp, body, xType, p, compiler, targetPackage);
ctorArgRegs.AddRange(valueRegs);
}
// Invoke ctor
DexLib.MethodReference dctor = attribute.Constructor.GetReference(targetPackage, compiler.Module);
body.Instructions.Add(seqp, RCode.Invoke_direct, dctor, ctorArgRegs.ToArray());
// set field values
foreach (var p in attribute.Fields)
{
var field = GetField(attributeTypeDef, p.Name);
var xField = XBuilder.AsFieldReference(compiler.Module, field);
Register[] valueRegs = CreateInitializeValueInstructions(seqp, body, xField.FieldType, p.Argument, compiler, targetPackage);
body.Instructions.Add(seqp, xField.FieldType.IPut(), xField.GetReference(targetPackage),
valueRegs[0], attributeReg);
}
// set property values
foreach (var p in attribute.Properties)
{
PropertyDefinition property = GetSettableProperty(attributeTypeDef, p.Name);
XTypeReference xType = XBuilder.AsTypeReference(compiler.Module, property.PropertyType);
Register[] valueRegs = CreateInitializeValueInstructions(seqp, body, xType, p.Argument, compiler, targetPackage);
XMethodDefinition xSetMethod = XBuilder.AsMethodDefinition(compiler.Module, property.SetMethod);
body.Instructions.Add(seqp, xSetMethod.Invoke(xSetMethod, null),
xSetMethod.GetReference(targetPackage),
new[] { attributeReg }.Concat(valueRegs).ToArray());
}
// Return attribute
body.Instructions.Add(seqp, RCode.Return_object, attributeReg);
// Register method body
targetPackage.Record(new CompiledMethod() { DexMethod = method, RLBody = body });
// Return method
return method;
}
/// <summary>
/// Record the attribute annotation information for the given attribute type.
/// </summary>
internal void Record(TypeDefinition attributeType, AttributeAnnotationMapping attributeAnnotationMapping)
{
attributeAnnotations.Add(attributeType, attributeAnnotationMapping);
}
/// <summary>
/// Record the attribute annotation information for the given attribute type.
/// </summary>
internal void Record(TypeDefinition attributeType, AttributeAnnotationMapping attributeAnnotationMapping)
{
attributeAnnotations.Add(attributeType, attributeAnnotationMapping);
}
