public ExportedType(string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
{
this.@namespace = @namespace;
this.name = name;
this.scope = scope;
this.module = module;
}
public static Collection<CustomAttribute> GetCustomAttributes(
this ICustomAttributeProvider self,
ref Collection<CustomAttribute> variable,
ModuleDefinition module)
{
return module.HasImage()
? module.Read(ref variable, self, (provider, reader) => reader.ReadCustomAttributes(provider))
: variable = new Collection<CustomAttribute>();
}
void CopyTo(CustomAttribute target, ModuleDefinition context)
{
foreach (var arg in ConstructorArguments)
target.ConstructorArguments.Add(new CustomAttributeArgument(context.Import(arg.Type), arg.Value));
foreach (var field in Fields)
target.Fields.Add(new CustomAttributeNamedArgument(field.Name, new CustomAttributeArgument(context.Import(field.Argument.Type), field.Argument.Value)));
foreach (var prop in Properties)
target.Properties.Add(new CustomAttributeNamedArgument(prop.Name, new CustomAttributeArgument(context.Import(prop.Argument.Type), prop.Argument.Value)));
}
public TypeReference(string @namespace, string name, ModuleDefinition module, IMetadataScope scope, bool valueType)
: this(@namespace, name, module, scope)
{
value_type = valueType;
}
public static Collection<SecurityDeclaration> GetSecurityDeclarations(
this ISecurityDeclarationProvider self,
ref Collection<SecurityDeclaration> variable,
ModuleDefinition module)
{
return module.HasImage()
? module.Read(ref variable, self, (provider, reader) => reader.ReadSecurityDeclarations(provider))
: variable = new Collection<SecurityDeclaration>();
}
public static bool GetHasSecurityDeclarations(
this ISecurityDeclarationProvider self,
ModuleDefinition module)
{
return module.HasImage() && module.Read(self, (provider, reader) => reader.HasSecurityDeclarations(provider));
}
internal SecurityDeclaration(SecurityAction action, uint signature, ModuleDefinition module)
{
this.action = action;
this.signature = signature;
this.module = module;
}
static TypeDefinition GetTypeDefinition(ModuleDefinition module, TypeReference type)
{
if (!type.IsNested)
return module.GetType(type.Namespace, type.Name);
var declaring_type = type.DeclaringType.Resolve();
if (declaring_type == null)
return null;
return declaring_type.GetNestedType(type.TypeFullName());
}
public static bool GetHasGenericParameters(
this IGenericParameterProvider self,
ModuleDefinition module)
{
return module.HasImage() && module.Read(self, (provider, reader) => reader.HasGenericParameters(provider));
}
public static void PatchAssemblyNames(ModuleDefinition module, string searchToken, Version searchVersion, string replaceToken, Version replaceVersion)
{
var references = SearchReferences(module, searchToken, searchVersion).ToList();
PatchAssemblyNames(references, replaceToken, replaceVersion);
}
public static bool GetHasCustomAttributes(
this ICustomAttributeProvider self,
ModuleDefinition module)
{
return module.HasImage() && module.Read(self, (provider, reader) => reader.HasCustomAttributes(provider));
}
public CoreTypeSystem(ModuleDefinition module)
: base(module)
{
}
internal static TypeSystem CreateTypeSystem(ModuleDefinition module)
{
if (module.IsCorlib())
return new CoreTypeSystem(module);
return new CommonTypeSystem(module);
}
private static TypeReference FixTypeImport(ModuleDefinition context, MethodDefinition source, MethodDefinition target,
TypeReference type)
{
if (type.FullName == source.DeclaringType.FullName)
return target.DeclaringType;
return context.Import(type);
}
private static MethodReference FixMethodImport(ModuleDefinition context, MethodDefinition source,
MethodDefinition target, MethodReference method)
{
if (method.DeclaringType.FullName == source.DeclaringType.FullName)
return FindMatchingMethod(target.DeclaringType, method);
return context.Import(method);
}
private static FieldReference FixFieldImport(ModuleDefinition context, MethodDefinition source,
MethodDefinition target, FieldReference field)
{
if (field.DeclaringType.FullName == source.DeclaringType.FullName)
return FindMatchingField(target.DeclaringType, field);
return context.Import(field);
}
public static IEnumerable<AssemblyNameReference> SearchReferences(ModuleDefinition module, string searchToken,
Version searchVersion)
{
return module.AssemblyReferences.Where(aname => ByteHelper.ByteToString(aname.PublicKeyToken) == searchToken && aname.Version == searchVersion);
}
public TypeReference(string @namespace, string name, ModuleDefinition module, IMetadataScope scope)
: this(@namespace, name)
{
this.module = module;
this.scope = scope;
}
// HACK - Reflexil - Ends
TypeSystem(ModuleDefinition module)
{
this.module = module;
}
public static TypeDefinition FindMatchingType(ModuleDefinition mdef, string fulltypename)
{
return FindMatchingType(mdef.Types, fulltypename);
}
internal static CustomAttribute Clone(CustomAttribute custattr, ModuleDefinition context)
{
var ca = new CustomAttribute(context.Import(custattr.Constructor));
custattr.CopyTo(ca, context);
return ca;
}
static TypeDefinition GetType(ModuleDefinition module, TypeReference reference)
{
var type = GetTypeDefinition(module, reference);
if (type != null)
return type;
if (!module.HasExportedTypes)
return null;
var exported_types = module.ExportedTypes;
for (int i = 0; i < exported_types.Count; i++)
{
var exported_type = exported_types[i];
if (exported_type.Name != reference.Name)
continue;
if (exported_type.Namespace != reference.Namespace)
continue;
return exported_type.Resolve();
}
return null;
}
public MetadataImporter(ModuleDefinition module)
{
this.module = module;
}
public static Collection<GenericParameter> GetGenericParameters(
this IGenericParameterProvider self,
ref Collection<GenericParameter> collection,
ModuleDefinition module)
{
return module.HasImage()
? module.Read(ref collection, self, (provider, reader) => reader.ReadGenericParameters(provider))
: collection = new GenericParameterCollection(self);
}
