/// <summary> /// Returns true if the given object is an identifier that identifies the same object as this identifier. /// </summary> //^ [Confined] public override bool Equals(object /*?*/ obj) { if (obj == (object)this) { return(true); } ModuleIdentity /*?*/ otherMod = obj as ModuleIdentity; if (otherMod == null) { return(false); } if (this.containingAssembly == null) { if (otherMod.ContainingAssembly != null) { return(false); } } else { if (otherMod.ContainingAssembly == null) { return(false); } if (!this.containingAssembly.Equals(otherMod.containingAssembly)) { return(false); } } if (this.Name.UniqueKeyIgnoringCase != otherMod.Name.UniqueKeyIgnoringCase) { return(false); } if (this.containingAssembly != null) { return(true); } return(string.Compare(this.Location, otherMod.Location, StringComparison.OrdinalIgnoreCase) == 0); }
/// <summary> /// Returns the module corresponding to passed moduleIdentifier if it was loaded. /// </summary> /// <param name="moduleIdentity"></param> /// <returns></returns> public IModule /*?*/ FindModule(ModuleIdentity moduleIdentity) { return(this.LookupModule(null, moduleIdentity)); }
/// <summary> /// The module that matches the given reference, or a dummy module if no matching module can be found. /// </summary> public virtual IModule LoadModule(ModuleIdentity moduleIdentity) { if (moduleIdentity.Location == null) return Dummy.Module; IUnit/*?*/ unit; lock (GlobalLock.LockingObject) { this.unitCache.TryGetValue(moduleIdentity, out unit); } if (unit == null) { if (moduleIdentity.Location == "" || moduleIdentity.Location == "unknown://location") { unit = Dummy.Module; this.unitCache.Add(moduleIdentity, unit); } else unit = this.LoadUnitFrom(moduleIdentity.Location); } IModule/*?*/ result = unit as IModule; if (result == null) result = Dummy.Module; return result; }
public IModule LoadModule(ModuleIdentity moduleIdentity) { Contract.Requires(moduleIdentity != null); Contract.Ensures(Contract.Result <IModule>() != null); throw new NotImplementedException(); }
/// <summary> /// This method is called when the module reference is being resolved and its not already loaded by the host. /// </summary> /// <param name="referringUnit">The unit that is referencing the module.</param> /// <param name="referencedModule">Module identifier for the assembly being referenced.</param> public void ResolvingModuleReference(IUnit referringUnit, ModuleIdentity referencedModule) { Contract.Requires(referringUnit != null); Contract.Requires(referencedModule != null); throw new NotImplementedException(); }
/// <summary> /// The module that matches the given reference, or a dummy module if no matching module can be found. /// </summary> public virtual IModule LoadModule(ModuleIdentity moduleIdentity) { IUnit/*?*/ unit; lock (GlobalLock.LockingObject) { this.unitCache.TryGetValue(moduleIdentity, out unit); } IModule/*?*/ result; if (unit != null) result = unit as IModule; else { if (moduleIdentity.Location == "" || moduleIdentity.Location == "unknown://location") { result = Dummy.Module; lock (GlobalLock.LockingObject) { this.unitCache.Add(moduleIdentity, result); } } else { unit = this.LoadUnitFrom(moduleIdentity.Location); result = unit as IModule; if (result != null) lock (GlobalLock.LockingObject) { this.unitCache.Add(moduleIdentity, result); this.coreIdentities.Add(result.CoreAssemblySymbolicIdentity); } } } if (result == null) result = Dummy.Module; return result; }
uint IInternFactory.GetModuleInternedKey(ModuleIdentity moduleIdentity) { lock (GlobalLock.LockingObject) { ModuleStore moduleStore = this.GetModuleStore(moduleIdentity); return moduleStore.InternedId; } }
internal ModuleStore( ModuleIdentity moduleIdentitity, uint internedId, uint rootNamespaceInternedId ) { this.ModuleIdentitity = moduleIdentitity; this.InternedId = internedId; this.RootNamespaceInternedId = rootNamespaceInternedId; }
public IModule LoadModule(ModuleIdentity moduleIdentity) { return Dummy.Module; }
public uint GetModuleInternedKey(ModuleIdentity moduleIdentity) { return m_factory.GetModuleInternedKey(moduleIdentity); }
ModuleIdentity IMetadataHost.ProbeModuleReference(IUnit referringUnit, ModuleIdentity referencedModule) { throw new NotImplementedException(); }
IModule IMetadataHost.LoadModule(ModuleIdentity moduleIdentity) { throw new NotImplementedException(); }
/// <summary> /// Allocates a reference to a .NET module. /// </summary> /// <param name="host">Provides a standard abstraction over the applications that host components that provide or consume objects from the metadata model.</param> /// <param name="moduleIdentity"></param> public ModuleReference(IMetadataHost host, ModuleIdentity moduleIdentity) { this.host = host; this.moduleIdentity = moduleIdentity; }
public uint GetModuleInternedKey(ModuleIdentity moduleIdentity) { return(m_factory.GetModuleInternedKey(moduleIdentity)); }
public ModuleIdentity ProbeModuleReference(IUnit referringUnit, ModuleIdentity referencedModule) { throw new NotImplementedException(); }
public ModuleIdentity ProbeModuleReference(IUnit unit, ModuleIdentity referedModuleIdentity) { return referedModuleIdentity; }
/// <summary> /// This method is called when the module reference is being resolved and its not already loaded by the Read/Write host. /// </summary> /// <param name="referringUnit">The unit that is referencing the module.</param> /// <param name="referencedModule">Module identity for the assembly being referenced.</param> public virtual void ResolvingModuleReference(IUnit referringUnit, ModuleIdentity referencedModule) { }
public uint GetModuleInternedKey(ModuleIdentity moduleIdentity) { return 0; }
ModuleStore GetModuleStore(ModuleIdentity moduleIdentity) { Contract.Requires(moduleIdentity != null); Contract.Ensures(Contract.Result<ModuleStore>() != null); IName moduleName = moduleIdentity.Name; foreach (ModuleStore mStore in this.ModuleHashtable.GetValuesFor((uint)moduleName.UniqueKey)) { if (moduleIdentity.Equals(mStore.ModuleIdentitity)) return mStore; } uint value; if (moduleIdentity.ContainingAssembly != null) { AssemblyStore assemblyStore = this.GetAssemblyStore(moduleIdentity.ContainingAssembly); assemblyStore.InternedIdWithCount++; value = assemblyStore.InternedIdWithCount; } else { value = this.CurrentModuleInternValue++; } ModuleStore mStore1 = new ModuleStore(moduleIdentity, value, this.CurrentNamespaceInternValue++); this.ModuleHashtable.Add((uint)moduleName.UniqueKey, mStore1); return mStore1; }
/// <summary> /// Method to open the module in the MetadataReader. This method loads the module and returns the object corresponding to the opened module. /// Also returns the ModuleIDentifier corresponding to the module as the out parameter. Modules are opened as if they are not contained in any assembly. /// </summary> /// <param name="binaryDocument">The binary document that needes to be opened as an module.</param> /// <param name="moduleIdentity">Contains the module identity of the binary document in case it is an module.</param> /// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns> public IModule OpenModule( IBinaryDocument binaryDocument, out ModuleIdentity/*?*/ moduleIdentity ) { moduleIdentity = null; lock (GlobalLock.LockingObject) { IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument); if (binaryDocumentMemoryBlock == null) { // Error... return Dummy.Module; } PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock); if (peFileReader.ReaderState < ReaderState.Metadata) { // Error... return Dummy.Module; } //^ assert peFileReader.ReaderState >= ReaderState.Metadata; if (peFileReader.IsAssembly) { AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader); moduleIdentity = assemblyIdentity; Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity); if (lookupAssembly != null) { return lookupAssembly; } } else { moduleIdentity = this.GetModuleIdentifier(peFileReader); Module/*?*/ lookupModule = this.LookupModule(null, moduleIdentity); if (lookupModule != null) { return lookupModule; } } try { PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize); this.LoadedModule(peFileToObjectModel.Module); Assembly/*?*/ assembly = peFileToObjectModel.Module as Assembly; if (assembly != null) { this.OpenMemberModules(binaryDocument, assembly); } return peFileToObjectModel.Module; } catch (MetadataReaderException) { // Error... } } return Dummy.Module; }
/// <summary> /// Finds the module that matches the given identifier among the already loaded set of modules, /// or a dummy module if no matching module can be found. /// </summary> public IModule FindModule(ModuleIdentity moduleIdentity) { IUnit/*?*/ unit; lock (GlobalLock.LockingObject) { this.unitCache.TryGetValue(moduleIdentity, out unit); } IModule/*?*/ result = unit as IModule; if (result != null) return result; return Dummy.Module; }
/// <summary> /// Does a look up in the loaded modules if the given module identified by moduleIdentifier is loaded. This also gives a chance to MetadataReaderHost to /// delay load the module if needed. /// </summary> /// <param name="referringModule"></param> /// <param name="moduleIdentity"></param> /// <returns></returns> internal Module/*?*/ LookupModule(IModule/*?*/ referringModule, ModuleIdentity moduleIdentity) { lock (GlobalLock.LockingObject) { uint internedModuleId = (uint)this.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity); Module/*?*/ module = this.InternedIdToModuleMap.Find(internedModuleId); if (module == null && referringModule != null) { this.metadataReaderHost.ResolvingModuleReference(referringModule, moduleIdentity); module = this.InternedIdToModuleMap.Find(internedModuleId); } return module; } }
public virtual ModuleIdentity ProbeModuleReference(IUnit referringUnit, ModuleIdentity referencedModule) { return new ModuleIdentity(referencedModule.Name, "unknown://location", referencedModule.ContainingAssembly); }
/// <summary> /// Returns the module corresponding to passed moduleIdentifier if it was loaded. /// </summary> /// <param name="moduleIdentity"></param> /// <returns></returns> public IModule/*?*/ FindModule(ModuleIdentity moduleIdentity) { return this.LookupModule(null, moduleIdentity); }
public IModule LoadModule(ModuleIdentity moduleIdentity) { throw new NotImplementedException(); }
public void ModuleOpened(IModule module, ModuleIdentity moduleIdentity, uint size) { ModuleOpened(module.Name.Value, moduleIdentity == null ? "" : moduleIdentity.Location, module.GetHashCode(), (int) size); }