/// <summary>
/// Constructor
/// </summary>
/// <param name="guid">GUID string</param>
/// <param name="nativeTypeName">Native type name string</param>
public CustomMarshalType(UTF8String guid, UTF8String nativeTypeName)
: this(guid, nativeTypeName, null, null)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="signature">Signature</param>
public FieldDefUser(UTF8String name, FieldSig signature)
: this(name, signature, 0)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="scope">Scope</param>
/// <param name="name">Name</param>
/// <param name="flags">Flags</param>
public ImplMapUser(ModuleRef scope, UTF8String name, PInvokeAttributes flags)
{
module = scope;
this.name = name;
attributes = (int)flags;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Simple name</param>
/// <param name="version">Version</param>
/// <exception cref="ArgumentNullException">If any of the args is invalid</exception>
public AssemblyRefUser(UTF8String name, Version version)
: this(name, version, new PublicKey())
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Simple name</param>
/// <param name="version">Version</param>
/// <param name="publicKey">Public key or public key token</param>
/// <param name="locale">Locale</param>
/// <exception cref="ArgumentNullException">If any of the args is invalid</exception>
public AssemblyRefUser(UTF8String name, Version version, PublicKeyBase publicKey, UTF8String locale)
{
if ((object)name == null)
{
throw new ArgumentNullException("name");
}
if (version == null)
{
throw new ArgumentNullException("version");
}
if ((object)locale == null)
{
throw new ArgumentNullException("locale");
}
this.name = name;
this.version = version;
this.publicKeyOrToken = publicKey;
this.culture = locale;
this.attributes = (int)(publicKey is PublicKey ? AssemblyAttributes.PublicKey : AssemblyAttributes.None);
}
/// <summary> /// Gets the hash code of a locale /// </summary> /// <param name="a">Value</param> /// <returns>The hash code</returns> internal static int GetHashCodeLocale(UTF8String a) => GetCanonicalLocale(a).GetHashCode();
/// <inheritdoc/>
public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule)
{
if (assembly == null)
{
return(null);
}
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
AssemblyDef resolvedAssembly = Resolve2(assembly, sourceModule);
if (resolvedAssembly == null)
{
string asmName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
string asmNameTrimmed = asmName.Trim();
if (asmName != asmNameTrimmed)
{
assembly = new AssemblyNameInfo {
Name = asmNameTrimmed,
Version = assembly.Version,
PublicKeyOrToken = assembly.PublicKeyOrToken,
Culture = assembly.Culture,
};
resolvedAssembly = Resolve2(assembly, sourceModule);
}
}
if (resolvedAssembly == null)
{
// Make sure we don't search for this assembly again. This speeds up callers who
// keep asking for this assembly when trying to resolve many different TypeRefs
cachedAssemblies[GetAssemblyNameKey(assembly)] = null;
return(null);
}
var key1 = GetAssemblyNameKey(resolvedAssembly);
var key2 = GetAssemblyNameKey(assembly);
AssemblyDef asm1, asm2;
cachedAssemblies.TryGetValue(key1, out asm1);
cachedAssemblies.TryGetValue(key2, out asm2);
if (asm1 != resolvedAssembly && asm2 != resolvedAssembly)
{
// This assembly was just resolved
if (enableTypeDefCache)
{
foreach (var module in resolvedAssembly.Modules.GetSafeEnumerable())
{
if (module != null)
{
module.EnableTypeDefFindCache = true;
}
}
}
}
bool inserted = false;
if (!cachedAssemblies.ContainsKey(key1))
{
cachedAssemblies.Add(key1, resolvedAssembly);
inserted = true;
}
if (!cachedAssemblies.ContainsKey(key2))
{
cachedAssemblies.Add(key2, resolvedAssembly);
inserted = true;
}
if (inserted || asm1 == resolvedAssembly || asm2 == resolvedAssembly)
{
return(resolvedAssembly);
}
// Dupe assembly. Don't insert it.
var dupeModule = resolvedAssembly.ManifestModule;
if (dupeModule != null)
{
dupeModule.Dispose();
}
return(asm1 ?? asm2);
#if THREAD_SAFE
}
finally { theLock.ExitWriteLock(); }
#endif
}
public ClassName(string ns, string name, bool isValueType = false)
{
Namespace = ns;
Name = name;
IsValueType = isValueType;
}
public bool Equals(ClassName other) => // Don't check IsValueType UTF8String.Equals(Namespace, other.Namespace) && UTF8String.Equals(Name, other.Name);
public bool Equals(Info other)
{
return(stricmp(Scope, other.Scope) &&
UTF8String.Equals(Identifier, other.Identifier));
}
private static Info?GetInfo(TypeDef td)
{
if (td == null)
{
return(null);
}
if (td.IsWindowsRuntime)
{
return(null);
}
UTF8String scope = null, identifier = null;
var tia = td.CustomAttributes.Find("System.Runtime.InteropServices.TypeIdentifierAttribute");
if (tia != null)
{
if (tia.ConstructorArguments.Count >= 2)
{
if (tia.ConstructorArguments[0].Type.GetElementType() != ElementType.String)
{
return(null);
}
if (tia.ConstructorArguments[1].Type.GetElementType() != ElementType.String)
{
return(null);
}
scope = tia.ConstructorArguments[0].Value as UTF8String ?? tia.ConstructorArguments[0].Value as string;
identifier = tia.ConstructorArguments[1].Value as UTF8String ?? tia.ConstructorArguments[1].Value as string;
}
}
else
{
var mod = td.Module;
var asm = mod == null ? null : mod.Assembly;
if (asm == null)
{
return(null);
}
bool isTypeLib = asm.CustomAttributes.IsDefined("System.Runtime.InteropServices.ImportedFromTypeLibAttribute") ||
asm.CustomAttributes.IsDefined("System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute");
if (!isTypeLib)
{
return(null);
}
}
if (UTF8String.IsNull(identifier))
{
CustomAttribute gca;
if (td.IsInterface && td.IsImport)
{
gca = td.CustomAttributes.Find("System.Runtime.InteropServices.GuidAttribute");
}
else
{
var mod = td.Module;
var asm = mod == null ? null : mod.Assembly;
if (asm == null)
{
return(null);
}
gca = asm.CustomAttributes.Find("System.Runtime.InteropServices.GuidAttribute");
}
if (gca == null)
{
return(null);
}
if (gca.ConstructorArguments.Count < 1)
{
return(null);
}
if (gca.ConstructorArguments[0].Type.GetElementType() != ElementType.String)
{
return(null);
}
scope = gca.ConstructorArguments[0].Value as UTF8String ?? gca.ConstructorArguments[0].Value as string;
var ns = td.Namespace;
var name = td.Name;
if (UTF8String.IsNullOrEmpty(ns))
{
identifier = name;
}
else if (UTF8String.IsNullOrEmpty(name))
{
identifier = new UTF8String(Concat(ns.Data, (byte)'.', empty));
}
else
{
identifier = new UTF8String(Concat(ns.Data, (byte)'.', name.Data));
}
}
return(new Info(scope, identifier));
}
public Info(UTF8String scope, UTF8String identifier)
{
this.Scope = scope;
this.Identifier = identifier;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="guid">GUID string</param>
/// <param name="nativeTypeName">Native type name string</param>
/// <param name="custMarshaler">Custom marshaler name string</param>
/// <param name="cookie">Cookie string</param>
public CustomMarshalType(UTF8String guid, UTF8String nativeTypeName, ITypeDefOrRef custMarshaler, UTF8String cookie)
: base(NativeType.CustomMarshaler)
{
this.guid = guid;
this.nativeTypeName = nativeTypeName;
this.custMarshaler = custMarshaler;
this.cookie = cookie;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="guid">GUID string</param>
/// <param name="nativeTypeName">Native type name string</param>
/// <param name="custMarshaler">Custom marshaler name string</param>
public CustomMarshalType(UTF8String guid, UTF8String nativeTypeName, ITypeDefOrRef custMarshaler)
: this(guid, nativeTypeName, custMarshaler, null)
{
}
/// <summary> /// Compares two locales (cultures) /// </summary> /// <param name="a">First</param> /// <param name="b">Second</param> /// <returns>< 0 if a < b, 0 if a == b, > 0 if a > b</returns> internal static int LocaleCompareTo(UTF8String a, string b) => GetCanonicalLocale(a).CompareTo(GetCanonicalLocale(b));
public override int GetHashCode() => // Don't use IsValueType UTF8String.GetHashCode(Namespace) ^ UTF8String.GetHashCode(Name);
/// <summary> /// Compares two locales (cultures) /// </summary> /// <param name="a">First</param> /// <param name="b">Second</param> /// <returns><c>true</c> if same, <c>false</c> otherwise</returns> internal static bool LocaleEquals(UTF8String a, string b) => LocaleCompareTo(a, b) == 0;
/// <summary>
/// Constructor
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="name">Type name</param>
public TypeRefUser(ModuleDef module, UTF8String name)
: this(module, UTF8String.Empty, name)
{
}
static string GetCanonicalLocale(UTF8String locale) => GetCanonicalLocale(UTF8String.ToSystemStringOrEmpty(locale));
/// <summary>
/// Constructor
/// </summary>
/// <param name="module">Owner module</param>
/// <param name="namespace">Type namespace</param>
/// <param name="name">Type name</param>
public TypeRefUser(ModuleDef module, UTF8String @namespace, UTF8String name)
: this(module, @namespace, name, null)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Simple name</param>
/// <exception cref="ArgumentNullException">If any of the args is invalid</exception>
public AssemblyRefUser(UTF8String name)
: this(name, new Version(0, 0, 0, 0))
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name of file</param>
/// <param name="flags">Flags</param>
/// <param name="hashValue">File hash</param>
public FileDefUser(UTF8String name, FileAttributes flags, byte[] hashValue)
{
this.name = name;
this.attributes = (int)flags;
this.hashValue = hashValue;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Simple name</param>
/// <param name="version">Version</param>
/// <param name="publicKey">Public key or public key token</param>
/// <exception cref="ArgumentNullException">If any of the args is invalid</exception>
public AssemblyRefUser(UTF8String name, Version version, PublicKeyBase publicKey)
: this(name, version, publicKey, UTF8String.Empty)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Simple name</param>
/// <param name="version">Version</param>
/// <param name="publicKey">Public key</param>
/// <param name="locale">Locale</param>
/// <exception cref="ArgumentNullException">If any of the args is invalid</exception>
public AssemblyDefUser(UTF8String name, Version version, PublicKey publicKey, UTF8String locale)
{
if ((object)name == null)
{
throw new ArgumentNullException("name");
}
if (version == null)
{
throw new ArgumentNullException("version");
}
if ((object)locale == null)
{
throw new ArgumentNullException("locale");
}
this.modules = new LazyList <ModuleDef>(this);
this.name = name;
this.version = version;
this.publicKey = publicKey ?? new PublicKey();
this.locale = locale;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
public FieldDefUser(UTF8String name)
: this(name, null)
{
}
/// <summary>
/// Figures out which of two assembly names is closer to another assembly name
/// </summary>
/// <param name="requested">Requested assembly name</param>
/// <param name="a">First</param>
/// <param name="b">Second</param>
/// <returns>-1 if both are equally close, 0 if a is closest, 1 if b is closest</returns>
public int CompareClosest(IAssembly requested, IAssembly a, IAssembly b)
{
if (a == b)
{
return(0);
}
if (a == null)
{
return(!CompareName ? 1 : UTF8String.CaseInsensitiveEquals(requested.Name, b.Name) ? 1 : 0);
}
if (b == null)
{
return(!CompareName ? 0 : UTF8String.CaseInsensitiveEquals(requested.Name, a.Name) ? 0 : 1);
}
// Compare the most important parts first:
// 1. Assembly simple name
// 2. Public key token
// 3. Version
// 4. Locale
if (CompareName)
{
// If the name only matches one of a or b, return that one.
bool na = UTF8String.CaseInsensitiveEquals(requested.Name, a.Name);
bool nb = UTF8String.CaseInsensitiveEquals(requested.Name, b.Name);
if (na && !nb)
{
return(0);
}
if (!na && nb)
{
return(1);
}
if (!na && !nb)
{
return(-1);
}
}
if (ComparePublicKeyToken)
{
bool pa, pb;
if (PublicKeyBase.IsNullOrEmpty2(requested.PublicKeyOrToken))
{
// If one of them has a pkt but the other one hasn't, return the one with
// no pkt.
pa = PublicKeyBase.IsNullOrEmpty2(a.PublicKeyOrToken);
pb = PublicKeyBase.IsNullOrEmpty2(b.PublicKeyOrToken);
}
else
{
// If one of them has the correct pkt, but the other one has an incorrect
// pkt, return the one with the correct pkt.
pa = PublicKeyBase.TokenEquals(requested.PublicKeyOrToken, a.PublicKeyOrToken);
pb = PublicKeyBase.TokenEquals(requested.PublicKeyOrToken, b.PublicKeyOrToken);
}
if (pa && !pb)
{
return(0);
}
if (!pa && pb)
{
return(1);
}
}
if (CompareVersion && !Utils.Equals(a.Version, b.Version))
{
var rv = Utils.CreateVersionWithNoUndefinedValues(requested.Version);
if (rv == new Version(0, 0, 0, 0))
{
rv = new Version(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
}
int va = Utils.CompareTo(a.Version, rv);
int vb = Utils.CompareTo(b.Version, rv);
if (va == 0)
{
return(0); // vb != 0 so return 0
}
if (vb == 0)
{
return(1); // va != 0 so return 1
}
if (va > 0 && vb < 0)
{
return(0);
}
if (va < 0 && vb > 0)
{
return(1);
}
// Now either both a and b's version > req version or both are < req version
if (va > 0)
{
// a.Version and b.Version > req.Version. Pick the one that is closest.
return(Utils.CompareTo(a.Version, b.Version) < 0 ? 0 : 1);
}
else
{
// a.Version and b.Version < req.Version. Pick the one that is closest.
return(Utils.CompareTo(a.Version, b.Version) > 0 ? 0 : 1);
}
}
if (CompareCulture)
{
bool la = Utils.LocaleEquals(requested.Culture, a.Culture);
bool lb = Utils.LocaleEquals(requested.Culture, b.Culture);
if (la && !lb)
{
return(0);
}
if (!la && lb)
{
return(1);
}
}
return(-1);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="signature">Signature</param>
/// <param name="attributes">Flags</param>
public FieldDefUser(UTF8String name, FieldSig signature, FieldAttributes attributes)
{
this.name = name;
this.signature = signature;
this.attributes = (int)attributes;
}
/// <summary>
/// Returns an assembly name string
/// </summary>
/// <param name="name">Simple assembly name</param>
/// <param name="version">Version or <c>null</c></param>
/// <param name="culture">Culture or <c>null</c></param>
/// <param name="publicKey">Public key / public key token or <c>null</c></param>
/// <param name="attributes">Assembly attributes</param>
/// <returns>An assembly name string</returns>
internal static string GetAssemblyNameString(UTF8String name, Version version, UTF8String culture, PublicKeyBase publicKey, AssemblyAttributes attributes)
{
var sb = new StringBuilder();
foreach (var c in UTF8String.ToSystemStringOrEmpty(name))
{
if (c == ',' || c == '=')
{
sb.Append('\\');
}
sb.Append(c);
}
if (version is not null)
{
sb.Append(", Version=");
sb.Append(CreateVersionWithNoUndefinedValues(version).ToString());
}
if (culture is not null)
{
sb.Append(", Culture=");
sb.Append(UTF8String.IsNullOrEmpty(culture) ? "neutral" : culture.String);
}
sb.Append(", ");
sb.Append(publicKey is null || publicKey is PublicKeyToken ? "PublicKeyToken=" : "PublicKey=");
sb.Append(publicKey is null ? "null" : publicKey.ToString());
if ((attributes & AssemblyAttributes.Retargetable) != 0)
{
sb.Append(", Retargetable=Yes");
}
if ((attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime)
{
sb.Append(", ContentType=WindowsRuntime");
}
return(sb.ToString());
}
MarshalType Read()
{
MarshalType returnValue;
try {
var nativeType = (NativeType)reader.ReadByte();
NativeType nt;
int size;
switch (nativeType)
{
case NativeType.FixedSysString:
size = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
returnValue = new FixedSysStringMarshalType(size);
break;
case NativeType.SafeArray:
var vt = CanRead() ? (VariantType)reader.ReadCompressedUInt32() : VariantType.NotInitialized;
var udtName = CanRead() ? ReadUTF8String() : null;
var udtRef = (object)udtName == null ? null : TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(udtName), null, gpContext);
returnValue = new SafeArrayMarshalType(vt, udtRef);
break;
case NativeType.FixedArray:
size = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
nt = CanRead() ? (NativeType)reader.ReadCompressedUInt32() : NativeType.NotInitialized;
returnValue = new FixedArrayMarshalType(size, nt);
break;
case NativeType.Array:
nt = CanRead() ? (NativeType)reader.ReadCompressedUInt32() : NativeType.NotInitialized;
int paramNum = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
size = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
int flags = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
returnValue = new ArrayMarshalType(nt, paramNum, size, flags);
break;
case NativeType.CustomMarshaler:
var guid = ReadUTF8String();
var nativeTypeName = ReadUTF8String();
var custMarshalerName = ReadUTF8String();
var cmRef = TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(custMarshalerName), new CAAssemblyRefFinder(module), gpContext);
var cookie = ReadUTF8String();
returnValue = new CustomMarshalType(guid, nativeTypeName, cmRef, cookie);
break;
case NativeType.IUnknown:
case NativeType.IDispatch:
case NativeType.IntF:
int iidParamIndex = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
return(new InterfaceMarshalType(nativeType, iidParamIndex));
default:
returnValue = new MarshalType(nativeType);
break;
}
}
catch {
returnValue = new RawMarshalType(reader.ReadAllBytes());
}
return(returnValue);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="guid">GUID string</param>
public CustomMarshalType(UTF8String guid)
: this(guid, null, null, null)
{
}
