internal static EventDefinition Clone(EventDefinition evt, ImportContext context) { EventDefinition ne = new EventDefinition( evt.Name, context.Import(evt.EventType), evt.Attributes); if (context != null && context.GenericContext.Type is TypeDefinition) { TypeDefinition type = context.GenericContext.Type as TypeDefinition; if (evt.AddMethod != null) { ne.AddMethod = type.Methods.GetMethod(evt.AddMethod.Name) [0]; } if (evt.InvokeMethod != null) { ne.InvokeMethod = type.Methods.GetMethod(evt.InvokeMethod.Name) [0]; } if (evt.RemoveMethod != null) { ne.RemoveMethod = type.Methods.GetMethod(evt.RemoveMethod.Name) [0]; } } foreach (CustomAttribute ca in evt.CustomAttributes) { ne.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } return(ne); }
internal static PropertyDefinition Clone(PropertyDefinition prop, ImportContext context) { PropertyDefinition np = new PropertyDefinition( prop.Name, context.Import(prop.PropertyType), prop.Attributes); if (prop.HasConstant) { np.Constant = prop.Constant; } if (context != null && context.GenericContext.Type is TypeDefinition) { TypeDefinition type = context.GenericContext.Type as TypeDefinition; if (prop.SetMethod != null) { np.SetMethod = type.Methods.GetMethod(prop.SetMethod.Name) [0]; } if (prop.GetMethod != null) { np.GetMethod = type.Methods.GetMethod(prop.GetMethod.Name) [0]; } } foreach (CustomAttribute ca in prop.CustomAttributes) { np.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } return(np); }
internal static FieldDefinition Clone(FieldDefinition field, ImportContext context) { FieldDefinition nf = new FieldDefinition( field.Name, context.Import(field.FieldType), field.Attributes); if (field.HasConstant) { nf.Constant = field.Constant; } if (field.MarshalSpec != null) { nf.MarshalSpec = field.MarshalSpec; } if (field.RVA != RVA.Zero) { nf.InitialValue = field.InitialValue; } else { nf.InitialValue = new byte [0]; } if (field.HasLayoutInfo) { nf.Offset = field.Offset; } foreach (CustomAttribute ca in field.CustomAttributes) { nf.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } return(nf); }
internal static GenericParameter Clone(GenericParameter gp, ImportContext context) { GenericParameter ngp; if (gp.Owner is TypeReference) { ngp = new GenericParameter(gp.m_name, context.GenericContext.Type); } else if (gp.Owner is MethodReference) { ngp = new GenericParameter(gp.m_name, context.GenericContext.Method); } else { throw new NotSupportedException(); } ngp.Position = gp.Owner.GenericParameters.IndexOf(gp); ngp.Attributes = gp.Attributes; if (gp.HasCustomAttributes) { foreach (CustomAttribute ca in gp.CustomAttributes) { ngp.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } } return(ngp); }
internal static ParameterDefinition Clone(ParameterDefinition param, ImportContext context) { ParameterDefinition np = new ParameterDefinition( param.Name, param.Sequence, param.Attributes, context.Import(param.ParameterType)); if (param.HasConstant) { np.Constant = param.Constant; } if (param.MarshalSpec != null) { np.MarshalSpec = param.MarshalSpec; } foreach (CustomAttribute ca in param.CustomAttributes) { np.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } return(np); }
internal static MethodDefinition Clone(MethodDefinition meth, ImportContext context) { MethodDefinition nm = new MethodDefinition(meth.Name, RVA.Zero, meth.Attributes, meth.ImplAttributes, meth.HasThis, meth.ExplicitThis, meth.CallingConvention); context.GenericContext.Method = nm; foreach (GenericParameter p in meth.GenericParameters) { nm.GenericParameters.Add(GenericParameter.Clone(p, context)); } nm.ReturnType.ReturnType = context.Import(meth.ReturnType.ReturnType); if (meth.ReturnType.HasConstant) { nm.ReturnType.Constant = meth.ReturnType.Constant; } if (meth.ReturnType.MarshalSpec != null) { nm.ReturnType.MarshalSpec = meth.ReturnType.MarshalSpec; } foreach (CustomAttribute ca in meth.ReturnType.CustomAttributes) { nm.ReturnType.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } if (meth.PInvokeInfo != null) { nm.PInvokeInfo = meth.PInvokeInfo; // TODO: import module ? } foreach (ParameterDefinition param in meth.Parameters) { nm.Parameters.Add(ParameterDefinition.Clone(param, context)); } foreach (MethodReference ov in meth.Overrides) { nm.Overrides.Add(context.Import(ov)); } foreach (CustomAttribute ca in meth.CustomAttributes) { nm.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } foreach (SecurityDeclaration sec in meth.SecurityDeclarations) { nm.SecurityDeclarations.Add(SecurityDeclaration.Clone(sec)); } if (meth.Body != null) { nm.Body = MethodBody.Clone(meth.Body, nm, context); } return(nm); }
internal static TypeDefinition Clone(TypeDefinition type, ImportContext context) { TypeDefinition nt = new TypeDefinition( type.Name, type.Namespace, type.Attributes); context.GenericContext.Type = nt; foreach (GenericParameter p in type.GenericParameters) { nt.GenericParameters.Add(GenericParameter.Clone(p, context)); } if (type.BaseType != null) { nt.BaseType = context.Import(type.BaseType); } if (type.HasLayoutInfo) { nt.ClassSize = type.ClassSize; nt.PackingSize = type.PackingSize; } foreach (FieldDefinition field in type.Fields) { nt.Fields.Add(FieldDefinition.Clone(field, context)); } foreach (MethodDefinition ctor in type.Constructors) { nt.Constructors.Add(MethodDefinition.Clone(ctor, context)); } foreach (MethodDefinition meth in type.Methods) { nt.Methods.Add(MethodDefinition.Clone(meth, context)); } foreach (EventDefinition evt in type.Events) { nt.Events.Add(EventDefinition.Clone(evt, context)); } foreach (PropertyDefinition prop in type.Properties) { nt.Properties.Add(PropertyDefinition.Clone(prop, context)); } foreach (TypeReference intf in type.Interfaces) { nt.Interfaces.Add(context.Import(intf)); } foreach (TypeDefinition nested in type.NestedTypes) { nt.NestedTypes.Add(Clone(nested, context)); } foreach (CustomAttribute ca in type.CustomAttributes) { nt.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } foreach (SecurityDeclaration dec in type.SecurityDeclarations) { nt.SecurityDeclarations.Add(SecurityDeclaration.Clone(dec)); } return(nt); }
void MarkCustomAttribute(CustomAttribute ca) { MarkMethod (ca.Constructor); if (!ca.Resolved) { ca = ca.Clone (); ca.Resolve (); } if (!ca.Resolved) return; MarkCustomAttributeParameters (ca); TypeReference constructor_type = ca.Constructor.DeclaringType; TypeDefinition type = constructor_type.Resolve (); if (type == null) throw new ResolutionException (constructor_type); MarkCustomAttributeProperties (ca, type); MarkCustomAttributeFields (ca, type); }