private TypeRef([NotNull] string typeName, [CanBeNull] AssemblyRef assembly)
    {
      Assert.ArgumentNotNull(typeName, "typeName");

      TypeName = typeName;
      Assembly = assembly ?? AssemblyRef.Empty;
    }
		public AssemblyReferenceNodeImpl(ITreeNodeGroup treeNodeGroup, ModuleDef asmRefOwnerModule, AssemblyRef assemblyRef) {
			TreeNodeGroup = treeNodeGroup;
			this.asmRefOwnerModule = new WeakReference(asmRefOwnerModule);
			// Make sure we don't hold on to the original reference since it could prevent GC of the
			// owner module.
			AssemblyRef = assemblyRef.ToAssemblyRef();
			AssemblyRef.Rid = assemblyRef.Rid;
		}
 public TypeDefOrRefSig FindOrCreateTypeRef(ModuleDef module, AssemblyRef asmRef, string ns, string name, bool isValueType)
 {
     var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, asmRef));
     if (isValueType)
         return new ValueTypeSig(typeRef);
     
     return new ClassSig(typeRef);
 }
Esempio n. 4
0
		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, Csvm oldOne) {
			this.deobfuscatorContext = deobfuscatorContext;
			this.module = module;
			if (oldOne.resource != null)
				this.resource = (EmbeddedResource)module.Resources[oldOne.module.Resources.IndexOf(oldOne.resource)];
			if (oldOne.vmAssemblyRef != null)
				this.vmAssemblyRef = module.ResolveAssemblyRef(oldOne.vmAssemblyRef.Rid);
		}
Esempio n. 5
0
		static MModule GetModule(AssemblyRef asmRef) {
			foreach (var mm in modules.Values) {
				var asm = mm.moduleDef.Assembly;
				if (asm != null && asm.FullName == asmRef.FullName)
					return mm;
			}
			return null;
		}
Esempio n. 6
0
		static void OverwriteAssembly(AssemblyRef dst, AssemblyRef src) {
			dst.Name = src.Name;
			dst.Version = src.Version;
			dst.PublicKeyOrToken = src.PublicKeyOrToken;
			dst.Culture = src.Culture;
			dst.Attributes = src.Attributes;
			dst.Hash = src.Hash;
		}
 public AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly)
 {
     if (parentAssembly == null)
         throw new ArgumentNullException("parentAssembly");
     if (r == null)
         throw new ArgumentNullException("r");
     this.r = r;
     this.parentAssembly = parentAssembly;
     this.LazyLoading = true;
 }
		internal AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly, DnSpyFileListTreeNode dnSpyFileListTreeNode) {
			if (parentAssembly == null)
				throw new ArgumentNullException("parentAssembly");
			if (dnSpyFileListTreeNode == null)
				throw new ArgumentNullException("dnSpyFileListTreeNode");
			if (r == null)
				throw new ArgumentNullException("r");
			this.r = r;
			this.dnSpyFileListTreeNode = dnSpyFileListTreeNode;
			this.parentAssembly = parentAssembly;
			this.LazyLoading = true;
		}
 /// <summary>
 /// Tries the load the referenced assembly.
 /// </summary>
 /// <param name="assemblyResolver">The assembly resolver.</param>
 /// <param name="assemblyNameReference">The assembly name reference.</param>
 /// <param name="source">The source.</param>
 /// <param name="logging">The logging.</param>
 /// <param name="directReference">if set to <c>true</c> [direct reference].</param>
 /// <returns></returns>
 private static AssemblyDef TryLoad(IAssemblyResolver assemblyResolver, AssemblyRef assemblyNameReference, ModuleDef source, ILogging logging, bool directReference)
 {
     try
     {
         logging.WriteDebug("TryLoad '{0}' from '{1}'", assemblyNameReference.FullName, source.FullName);
         var assemblyDef = assemblyResolver.Resolve(assemblyNameReference, source);
         if (assemblyDef == null && directReference)
         {
             logging.WriteWarning("Can't load '{0}'", assemblyNameReference.FullName);
         }
         return(assemblyDef);
     }
     catch (FileNotFoundException)
     { }
     logging.WriteError("Failed loading '{0}'", assemblyNameReference.FullName);
     return(null);
 }
Esempio n. 10
0
        /// <summary>
        /// 排序并返回列表。
        /// </summary>
        public System.Collections.Generic.List <DatabaseSchemaHandler> Sort()
        {
            System.Collections.Generic.List <DatabaseSchemaHandler> list = new System.Collections.Generic.List <DatabaseSchemaHandler>();
            //foreach(AssemblyRef
            System.Collections.Generic.Dictionary <string, SortEntry> refOrders = new System.Collections.Generic.Dictionary <string, SortEntry>();
            System.Collections.Generic.List <AssemblyRef>             all       = LinqHelper.ToList(_refs.Values);

            SortAction action = null; action = (p1, p2) => {
                foreach (string p11 in p1.refs)
                {
                    AssemblyRef p12;
                    if (_refs.TryGetValue(p11, out p12))
                    {
                        if (all.Remove(p12))
                        {
                            action(p12, p2 * 1000);
                        }
                    }
                }
                SortEntry p10 = new SortEntry()
                {
                    item  = p1,
                    order = p2 * (refOrders.Count + 1)
                };
                refOrders.Add(p1.fullName, p10);
                return(p10);
            };

            while (all.Count > 0)
            {
                AssemblyRef item = all[0];
                all.RemoveAt(0);
                action(item, -1);
            }
            SortFunc classOrderGetter = (p1) => p1.Attribute.Order + GetClassRef(p1.Attribute.TableName, p1.Attribute.References);

            foreach (SortEntry p1 in LinqHelper.OrderByDescending(refOrders.Values, p => p.order))
            {
                list.AddRange(p1.item.SortList(classOrderGetter));
            }
            refOrders.Clear();
            refOrders = null;
            all       = null;
            return(list);
        }
Esempio n. 11
0
		private ISymbolWriter LoadSymbolWriter(AssemblyDefinition assembly, AssemblyRef output)
		{
			// TODO: Get symbol writing to work.
//			ISymbolWriterProvider symProv = null;
//			if (this.usingMdb) {
//				symProv = new Mono.Cecil.Mdb.MdbWriterProvider ();
//			} else if (this.usingPdb) {
//				symProv = new Mono.Cecil.Pdb.PdbWriterProvider ();
//			} else {
//				this.warnings.Add ("-writePDBFile specified, but no symbol file found, cannot write symbols.");
//			}
//			if (symProv != null) {
//				return output.IsFilename ?
//					symProv.GetSymbolWriter (assembly.MainModule, output.Filename) :
//					symProv.GetSymbolWriter (assembly.MainModule, output.Streams.Symbols);
//			}
			return null;
		}
Esempio n. 12
0
        void CacheRef(System.Reflection.Assembly assembly, DatabaseSchemaHandler handler)
        {
            AssemblyRef item;
            string      fullName = assembly.FullName;

            if (_refs.TryGetValue(fullName, out item))
            {
                item.list.Add(handler);
                return;
            }
            item = new AssemblyRef()
            {
                fullName = assembly.FullName,
                refs     = LinqHelper.ToArray(LinqHelper.Select(assembly.GetReferencedAssemblies(), p => p.FullName)),
                list     = new System.Collections.Generic.List <DatabaseSchemaHandler>(),
            };
            item.list.Add(handler);
            _refs.Add(fullName, item);
        }
Esempio n. 13
0
 internal AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly, AssemblyListTreeNode assemblyListTreeNode)
 {
     if (parentAssembly == null)
     {
         throw new ArgumentNullException("parentAssembly");
     }
     if (assemblyListTreeNode == null)
     {
         throw new ArgumentNullException("assemblyListTreeNode");
     }
     if (r == null)
     {
         throw new ArgumentNullException("r");
     }
     this.r = r;
     this.assemblyListTreeNode = assemblyListTreeNode;
     this.parentAssembly       = parentAssembly;
     this.LazyLoading          = true;
 }
Esempio n. 14
0
        private static void Hook_SpriteFetcher_GetSprite(ModuleDefMD module)
        {
            TypeDef   cecilSource  = module.Find("SpriteFetcher", isReflectionName: true);
            MethodDef sourceMethod = cecilSource.Methods.Single(m => m.FullName == "UnityEngine.Sprite SpriteFetcher::GetSprite(ObjectTypes,System.Int32)");
            TypeDef   cecilTarget  = module.GetNuterraType(typeof(Hooks.ResourceLookup));
            MethodDef targetMethod = cecilTarget.Methods.Single(m => m.Name == nameof(Hooks.ResourceLookup.GetSprite));

            AssemblyRef   unityEngine        = module.GetAssemblyRef(new UTF8String("UnityEngine"));
            TypeRefUser   unityEngine_Object = new TypeRefUser(module, new UTF8String("UnityEngine"), new UTF8String("Object"), unityEngine);
            TypeSig       objectSig          = unityEngine_Object.ToTypeSig();
            MethodSig     op_Equality        = MethodSig.CreateStatic(module.CorLibTypes.Boolean, objectSig, objectSig);
            MemberRefUser op_EqualityMethod  = new MemberRefUser(module, new UTF8String("op_Inequality"), op_Equality, unityEngine_Object);

            var body = sourceMethod.Body.Instructions;
            var originalMethodStart = body.First();
            int index = 0;

            sourceMethod.Body.MaxStack = 6;
            body.Insert(index++, new Instruction(OpCodes.Ldarg_1));
            body.Insert(index++, new Instruction(OpCodes.Ldarg_2));
            body.Insert(index++, new Instruction(OpCodes.Call, targetMethod));
            body.Insert(index++, new Instruction(OpCodes.Stloc_0));
            body.Insert(index++, new Instruction(OpCodes.Ldloc_0));
            body.Insert(index++, new Instruction(OpCodes.Ldnull));
            body.Insert(index++, new Instruction(OpCodes.Call, op_EqualityMethod));
            body.Insert(index++, new Instruction(OpCodes.Brfalse_S, originalMethodStart));
            body.Insert(index++, new Instruction(OpCodes.Ldloc_0));
            body.Insert(index++, new Instruction(OpCodes.Ret));

            /*
             *      0	0000	ldarg.1
             *      1	0001	ldarg.2
             *      2	0002	call		class [UnityEngine]UnityEngine.Sprite Maritaria.BlockLoader::SpriteFetcher_GetSprite(valuetype ObjectTypes, int32)
             *      3	0007	stloc.0
             *      4	0008	ldloc.0
             *      5	0009	ldnull
             *      6	000A	call		bool [UnityEngine]UnityEngine.Object::op_Inequality(class [UnityEngine]UnityEngine.Object, class [UnityEngine]UnityEngine.Object)
             *      7	000F	brfalse.s	{ original method start instruction }
             *      8	0011	ldloc.0
             *      9	0012	ret
             *      ... remaining method code ...
             */
        }
        void Write(BinaryWriter writer, AssemblyRef asmRef)
        {
            writer.Write((byte)Table.AssemblyRef);

            bool canWriteAsm = IsNonObfuscatedAssembly(asmRef);

            writer.Write(canWriteAsm);
            if (canWriteAsm)
            {
                bool hasPk = !PublicKeyBase.IsNullOrEmpty2(asmRef.PublicKeyOrToken);
                writer.Write(hasPk);
                if (hasPk)
                {
                    writer.Write(PublicKeyBase.ToPublicKeyToken(asmRef.PublicKeyOrToken).Data);
                }
                writer.Write(asmRef.Name);
                writer.Write(asmRef.Culture);
            }
        }
Esempio n. 16
0
        public bool ResolveReference(AssemblyRef reference, ModuleDef module, AssemblyResolver resolver)
        {
            ProcessModule(module);
            if (_cache.Count < 1)
            {
                return(false);
            }

            var found = _cache.TryGetValue(reference.Name, out var asm);

            if (!found)
            {
                return(false);
            }

            resolver.AddToCache(asm);
            resolver.ResolveThrow(reference, module);
            return(true);
        }
Esempio n. 17
0
		public ResourceOptions(Resource resource) {
			this.ResourceType = resource.ResourceType;
			this.Name = resource.Name ?? UTF8String.Empty;
			this.Attributes = resource.Attributes;
			switch (resource.ResourceType) {
			case ResourceType.Embedded:
				break;

			case ResourceType.AssemblyLinked:
				this.Assembly = ((AssemblyLinkedResource)resource).Assembly;
				break;

			case ResourceType.Linked:
				this.File = ((LinkedResource)resource).File;
				break;

			default:
				throw new InvalidOperationException();
			}
		}
Esempio n. 18
0
        void Hash(AssemblyRef asmRef)
        {
            if (asmRef == null)
            {
                return;
            }

            bool canWriteAsm = IsNonObfuscatedAssembly(asmRef);

            hasher.Hash(canWriteAsm ? 1 : 0);
            if (canWriteAsm)
            {
                bool hasPk = !PublicKeyBase.IsNullOrEmpty2(asmRef.PublicKeyOrToken);
                if (hasPk)
                {
                    hasher.Hash(PublicKeyBase.ToPublicKeyToken(asmRef.PublicKeyOrToken).Data);
                }
                Hash(asmRef.Name);
                Hash(asmRef.Culture);
            }
        }
        public void AssemblyRef_Create_IsInitialisedCorrectlyFromSource()
        {
            Mock <IStringStream>        stringStream = new Mock <IStringStream>();
            AssemblyDef                 assemblyDef  = new AssemblyDef();
            BuildReferences             references   = new BuildReferences();
            AssemblyRefMetadataTableRow row          = BuildTestMetadataRow();

            references.Assembly      = assemblyDef;
            assemblyDef.StringStream = stringStream.Object;

            // setup string methods to return strings in createfrom... method
            stringStream.Setup(p => p.GetString(CultureIndex)).Returns("culture");
            stringStream.Setup(p => p.GetString(NameIndex)).Returns("name");

            AssemblyRef reference = AssemblyRef.CreateFromMetadata(references, row);

            Assert.AreEqual("1.4.10.1204", reference.Version.ToString());
            Assert.AreEqual("culture", reference.Culture);
            Assert.AreEqual("name", reference.Name);
            Assert.AreSame(assemblyDef, reference.Assembly);
        }
Esempio n. 20
0
        public ResourceOptions(Resource resource)
        {
            ResourceType = resource.ResourceType;
            Name         = resource.Name ?? UTF8String.Empty;
            Attributes   = resource.Attributes;
            switch (resource.ResourceType)
            {
            case ResourceType.Embedded:
                break;

            case ResourceType.AssemblyLinked:
                Assembly = ((AssemblyLinkedResource)resource).Assembly;
                break;

            case ResourceType.Linked:
                File = ((LinkedResource)resource).File;
                break;

            default:
                throw new InvalidOperationException();
            }
        }
Esempio n. 21
0
        /// <summary>
        /// Resolve a TypeDef or TypeRef from its name. If neither a TypeDef or TypeRef are found
        /// in the module, search its references (AssemblyRefs) and if a match is found, add a TypeRef
        /// for it to the module and return that.
        /// </summary>
        /// <param name="fullName">Name of TypeDef or TypeRef as found in the resource</param>
        /// <param name="isReflectionName">Whether or not the name is a reflection name</param>
        /// <returns>TypeDef or TypeRef, or null if none found</returns>
        public ITypeDefOrRef ResolveTypeDefOrRef(TypeName typeName)
        {
            String fullName = typeName.Name;

            // Return TypeDef if found
            TypeDef typeDef = _module.Find(fullName, false);

            if (typeDef != null)
            {
                return(typeDef);
            }

            // Return existing TypeRef if found
            var typeRefs = _module.GetTypeRefs();

            foreach (var typeRef in typeRefs)
            {
                if (typeRef.FullName.Equals(fullName))
                {
                    return(typeRef);
                }
            }

            // Get the AssemblyRef from the type name and make our own TypeRef
            AssemblyRef asmRef = this.FindAssemblyRef(typeName);

            if (!typeName.IsNested)
            {
                return(new TypeRefUser(_module, typeName.Namespace, typeName.NameWithoutNamespace, asmRef));
            }
            else
            {
                // Lazy...
                var     parentName    = typeName.ParentName.Split('.').Last();
                TypeRef resolutionRef = new TypeRefUser(_module, typeName.Namespace, parentName, asmRef);
                return(new TypeRefUser(_module, "", typeName.NestedName, resolutionRef));
            }
        }
Esempio n. 22
0
        //public static bool LocateLoggerMethods(PEFile file, string assemblyName, string className, out Method startLogMethod, out Method endLogMethod)
        //{

        //    startLogMethod = endLogMethod = null;

        //    // Check if it is in this assembly itself
        //    if (file.GetThisAssembly().Name() == assemblyName)
        //    {
        //        ClassDef methodLogger = file.GetClass(className);

        //        if (methodLogger != null)
        //        {
        //            return GetLoggerMethodsFromClass(methodLogger, out startLogMethod, out endLogMethod);
        //        }
        //    }

        //    // Check referenced assemblies
        //    foreach (AssemblyRef assemblyRef in file.GetImportedAssemblies())
        //    {
        //        if (assemblyRef.Name() == assemblyName)
        //        {
        //            ClassRef methodLoggerRef = TryGetMethodLoggerFromAssembly(assemblyRef, className);
        //            if (methodLoggerRef != null)
        //            {
        //                if (GetLoggerMethodsFromClass(methodLoggerRef, out startLogMethod, out endLogMethod))
        //                    return true;
        //            }
        //        }
        //    }

        //    // Not found in this assembly or referenced assemblies. Try loading given assembly and adding it as reference
        //    AssemblyRef newAssemblyRef = file.MakeExternAssembly(assemblyName);
        //    ClassRef newMethodLoggerRef = TryGetMethodLoggerFromAssembly(newAssemblyRef, className);
        //    if (newMethodLoggerRef != null)
        //    {
        //        if (GetLoggerMethodsFromClass(newMethodLoggerRef, out startLogMethod, out endLogMethod))
        //            return true;
        //    }
        //    return false;
        //}

        private static ClassRef TryGetMethodLoggerFromAssembly(PEFile pef, AssemblyRef assemblyRef, string className)
        {
            //string fileName = "";
            //if (assemblyRef.Name().ToLower().EndsWith(".dll")|| assemblyRef.Name().ToLower().EndsWith(".exe"))
            //    fileName = assemblyRef.Name();
            //else
            // fileName = assemblyRef.Name() + ".exe";
            ////Console.WriteLine("TryGetMethodLoggerFromAssembly ->" + fileName);
            //if (!System.IO.File.Exists(fileName))
            //{
            //    Console.WriteLine(fileName + " not present in current directory. Skipping it in search");
            //    return null;
            //}



            PEFile   refFile      = pef;//PEFile.ReadPEFile(fileName);
            ClassDef methodLogger = refFile.GetClass(className);

            if (methodLogger != null)
            {
                ClassRef methodLoggerRef = methodLogger.MakeRefOf();
                if (assemblyRef.GetClass(className) == null)
                {
                    assemblyRef.AddClass(methodLoggerRef);
                }

                System.Array.ForEach(methodLogger.GetMethods(), delegate(MethodDef methodDef)
                {
                    if (methodLoggerRef.GetMethod(methodDef.Name()) == null)
                    {
                        methodLoggerRef.AddMethod(methodDef.Name(), methodDef.GetRetType(), methodDef.GetParTypes());
                    }
                });
                return(methodLoggerRef);
            }
            return(null);
        }
Esempio n. 23
0
 public AssemblyRefInfo(AssemblyRef asmRef)
 {
     AssemblyRef          = asmRef;
     OrigName             = asmRef.Name;
     OrigPublicKeyOrToken = asmRef.PublicKeyOrToken;
 }
Esempio n. 24
0
        public TreeNode NewAssemblyRef(AssemblyRef assemblyRef)
        {
            TreeNode node = NewNode(assemblyRef.FullName, false);
            node.Tag = assemblyRef;
            node.ImageIndex = node.SelectedImageIndex = 0;

            return node;
        }
Esempio n. 25
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">The owner module</param>
 /// <param name="corLibAssemblyRef">Corlib assembly reference or <c>null</c> if a default
 /// assembly reference should be created</param>
 public CorLibTypes(ModuleDef module, AssemblyRef corLibAssemblyRef)
 {
     this.module            = module;
     this.corLibAssemblyRef = corLibAssemblyRef ?? CreateCorLibAssemblyRef();
     Initialize();
 }
Esempio n. 26
0
 public override AssemblyReferenceNode Create(AssemblyRef asmRef) => Context.DocumentTreeView.Create(asmRef, moduleNode.Document.ModuleDef);
Esempio n. 27
0
		static bool IsGreaterAssemblyRefVersion(AssemblyRef found, AssemblyRef newOne) {
			if (found == null)
				return true;
			var foundVer = found.Version;
			var newVer = newOne.Version;
			return foundVer == null || (newVer != null && newVer >= foundVer);
		}
Esempio n. 28
0
 /// <summary>
 /// Creates a <see cref="AssemblyReferenceNode"/>
 /// </summary>
 /// <param name="asmRef">Assembly reference</param>
 /// <returns></returns>
 public abstract AssemblyReferenceNode Create(AssemblyRef asmRef);
Esempio n. 29
0
		public void Find() {
			resource = FindCsvmResource();
			vmAssemblyRef = FindVmAssemblyRef();
		}
Esempio n. 30
0
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="assembly">Target assembly</param>
		/// <param name="namespace">Namespace</param>
		public NamespaceReference(IAssembly assembly, string @namespace) {
			if (assembly == null)
				throw new ArgumentNullException(nameof(assembly));
			Assembly = assembly.ToAssemblyRef();
			Namespace = @namespace;
		}
Esempio n. 31
0
 public virtual DocumentTreeNodeFilterResult GetResult(AssemblyRef asmRef) => new DocumentTreeNodeFilterResult();
Esempio n. 32
0
        private void ParseTables()
        {
            byte[] buffer = new byte[256];
            file.Seek(metadata.StreamHeaders[meta_table_index].Offset, SeekOrigin.Begin);

            file.Read(buffer, 0, 4); // Reserved DWORD = 0
            file.Read(buffer, 0, 1); // Major version
            file.Read(buffer, 0, 1); // Minor version
            file.Read(buffer, 0, 1); // Heap offset sizes
            char heap_offset_sizes = BitConverter.ToChar(buffer, 0);
            file.Read(buffer, 0, 1); // Reserved byte = 0

            string_indices_are_dword = ((heap_offset_sizes & 1) != 0);
            guid_indices_are_dword = ((heap_offset_sizes & 2) != 0);
            blob_indices_are_dword = ((heap_offset_sizes & 4) != 0);

            UInt64 table_mask = 0;
            file.Read(buffer, 0, 8);
            table_mask = BitConverter.ToUInt64(buffer, 0);

            UInt64 sorted_mask = 0;
            file.Read(buffer, 0, 8);
            sorted_mask = BitConverter.ToUInt64(buffer, 0);

            // Count the tables
            int num_tables = 0;
            for (int i = 0; i < 64; ++i)
            {
                if ((table_mask & ((ulong)1 << i)) != 0) ++num_tables;
            }

            // Get the sizes
            UInt32[] table_sizes = new UInt32[64];
            int highest_used_table = 0;
            for (int i = 0; i < 64; ++i)
            {
                uint size = 0;
                if ((table_mask & ((ulong)1 << i)) != 0)
                {
                    file.Read(buffer, 0, 4);
                    size = BitConverter.ToUInt32(buffer, 0);
                    highest_used_table = i;
                }
                table_sizes[i] = size;
            }

            ComputeIndexSizes(table_sizes);

            // Process the tables
            for (int i = 0; i <= highest_used_table; ++i)
            {
                if ((table_mask & ((ulong)1 << i)) != 0)
                {
                    uint num_entries = table_sizes[i];
                    for (int j = 0; j < num_entries; ++j)
                    {
                        switch (i)
                        {
                            case 0: // Modules
                                file.Read(buffer, 0, 2); // Generation = 0
                                uint index = ReadStringIndex(); // Name
                                Name = ReadStringByIndex(index);
                                ReadGUIDIndex(); // MVID
                                ReadGUIDIndex(); // EncID
                                ReadGUIDIndex(); // EncBaseID
                                break;
                            case 1: // TypeRef
                                file.Read(buffer, 0, size_resolution_scope);
                                ReadStringIndex(); // TypeName
                                ReadStringIndex(); // TypeNamespace
                                break;
                            case 2: // TypeDef
                                file.Read(buffer, 0, 4); // Flags
                                ReadStringIndex(); // TypeName
                                ReadStringIndex(); // TypeNamespace
                                file.Read(buffer, 0, size_type_def_of_ref); // Extends
                                file.Read(buffer, 0, size_field_index);// FieldList
                                file.Read(buffer, 0, size_method_index);// MethodList
                                break;
                            case 4: // Field
                                file.Read(buffer, 0, 2); // Flags
                                ReadStringIndex(); // Name
                                ReadBlobIndex(); // Signature
                                break;
                            case 6: // MethodDef
                                file.Read(buffer, 0, 4); // RVA
                                file.Read(buffer, 0, 2); // ImplFlags
                                file.Read(buffer, 0, 2); // Flags
                                ReadStringIndex(); // Name
                                ReadBlobIndex(); // Signature
                                file.Read(buffer, 0, size_param_index); // ParamList
                                break;
                            case 8: // Param
                                file.Read(buffer, 0, 2); // Flags
                                file.Read(buffer, 0, 2); // Sequence
                                ReadStringIndex(); // Name
                                break;
                            case 9: // InterfaceImpl
                                file.Read(buffer, 0, size_type_def_index); // Class
                                file.Read(buffer, 0, size_type_def_of_ref); // Interface
                                break;
                            case 10: // MemberRef
                                file.Read(buffer, 0, size_member_ref_parent); // Class
                                ReadStringIndex(); // Name
                                ReadBlobIndex(); // Index
                                break;
                            case 11: // Constant
                                file.Read(buffer, 0, 2); // Type
                                file.Read(buffer, 0, size_has_constant); // Parent
                                ReadBlobIndex(); // Value
                                break;
                            case 12: // CustomAttribute
                                file.Read(buffer, 0, size_has_custom_attribute); // Parent
                                file.Read(buffer, 0, size_custom_attribute_type); // Type
                                ReadBlobIndex(); // Value
                                break;
                            case 13: // FieldMarshall
                                file.Read(buffer, 0, size_has_field_marshall); // Parent
                                ReadBlobIndex(); // NativeType
                                break;
                            case 14: // DeclSecurity
                                file.Read(buffer, 0, 2); // Action
                                file.Read(buffer, 0, size_has_decl_security); // Parent
                                ReadBlobIndex(); // PermissionSet
                                break;
                            case 15: // ClassLayout
                                file.Read(buffer, 0, 2); // PackingSize
                                file.Read(buffer, 0, 4); // ClassSize
                                file.Read(buffer, 0, size_type_def_index); // Parent
                                break;
                            case 16: // FieldLayout
                                file.Read(buffer, 0, 4); // Offset
                                file.Read(buffer, 0, size_field_index); // Field
                                break;
                            case 17: // StandaloneSig
                                ReadBlobIndex(); // Signature
                                break;
                            case 18: // EventMapTable
                                file.Read(buffer, 0, size_type_def_index); // Parent
                                file.Read(buffer, 0, size_event_index); // EventList
                                break;
                            case 20: // Event
                                file.Read(buffer, 0, 2); // EventFlag
                                ReadStringIndex(); // Name
                                file.Read(buffer, 0, size_type_def_of_ref); // EventType
                                break;
                            case 21: // PropertyMap
                                file.Read(buffer, 0, size_type_def_index); // Parent
                                file.Read(buffer, 0, size_property_index); // Parent
                                break;
                            case 23: // PropertyTable
                                file.Read(buffer, 0, 2); // Flags
                                ReadStringIndex(); // Name
                                ReadBlobIndex(); // Type
                                break;
                            case 24: // MethodSemantics
                                file.Read(buffer, 0, 2); // Semantics
                                file.Read(buffer, 0, size_method_index); // Method
                                file.Read(buffer, 0, size_has_semantic); // Association
                                break;
                            case 25: // MethodImplTable
                                file.Read(buffer, 0, size_type_def_index); // Class
                                file.Read(buffer, 0, size_method_def_or_ref); // MethodBody
                                file.Read(buffer, 0, size_method_def_or_ref); // MethodDeclaration
                                break;
                            case 26: // ModuleRef
                                ReadStringIndex(); // Name
                                break;
                            case 27: // TypeSpec
                                ReadBlobIndex(); // Signature
                                break;
                            case 28: // ImplMap
                                file.Read(buffer, 0, 2); // MappingFlags
                                file.Read(buffer, 0, size_member_forwarded); // MemberForwarded
                                ReadStringIndex(); // ImportName
                                file.Read(buffer, 0, size_module_ref_index); // ImportScope
                                break;
                            case 29: // FieldRVA
                                file.Read(buffer, 0, 4); // RVA
                                file.Read(buffer, 0, size_field_index); // Field
                                break;
                            case 32: // Assembly
                                file.Read(buffer, 0, 4); // HashAlgId
                                file.Read(buffer, 0, 2); // MajVersion
                                file.Read(buffer, 0, 2); // MinVersion
                                file.Read(buffer, 0, 2); // BuildNumber
                                file.Read(buffer, 0, 2); // RevisionNumber
                                file.Read(buffer, 0, 4); // Flags
                                AssemblyFlags = BitConverter.ToUInt32(buffer, 0);
                                AssemblyFlagsOffset = file.Position - 4;
                                AssemblyPublicKeyIndexOffset = file.Position;
                                AssemblyPublicKeyIndex = ReadBlobIndex(); // Public Key
                                ReadStringIndex(); // Name
                                ReadStringIndex(); // Culture

                                // Get Public Key
                                long save_pos = file.Position;
                                file.Seek(metadata.StreamHeaders[blob_table_index].Offset + AssemblyPublicKeyIndex, SeekOrigin.Begin);
                                PublicKey = ReadPublicKeyToken((AssemblyFlags & 1) != 0);
                                file.Seek(save_pos, SeekOrigin.Begin);
                                break;
                            case 33: // AssemblyProcessor
                                file.Read(buffer, 0, 4); // Processor
                                break;
                            case 34: // AssemblyOS
                                file.Read(buffer, 0, 4); // OSPlatformID
                                file.Read(buffer, 0, 4); // OSMajorVersion
                                file.Read(buffer, 0, 4); // OSMinorVersion
                                break;
                            case 35: // AssemblyRef
                                long base_offset = file.Position;
                                file.Read(buffer, 0, 12);

                                AssemblyRef assembly_ref = new AssemblyRef();
                                assembly_ref.VersionOffset = base_offset;
                                assembly_ref.MajVersion = BitConverter.ToUInt16(buffer, 0);
                                assembly_ref.MinVersion = BitConverter.ToUInt16(buffer, 2);
                                assembly_ref.BuildNumber = BitConverter.ToUInt16(buffer, 4);
                                assembly_ref.RevisionNumber = BitConverter.ToUInt16(buffer, 6);
                                assembly_ref.FlagsOffset = base_offset + 8;
                                assembly_ref.Flags = BitConverter.ToUInt32(buffer, 8);
                                assembly_ref.PublicKeyOrTokenOffset = base_offset + 12;
                                assembly_ref.PublicKeyOrToken = ReadBlobIndex();
                                assembly_ref.NameStringIndexOffset = base_offset + 12 + (blob_indices_are_dword ? 4 : 2);
                                assembly_ref.NameStringIndex = ReadStringIndex();
                                assembly_ref.CultureStringIndex = ReadStringIndex();
                                assembly_ref.HashValueIndex = ReadBlobIndex();

                                if (assembly_ref.NameStringIndex != 0)
                                {
                                    assembly_ref.Name = ReadStringByIndex(assembly_ref.NameStringIndex);
                                }
                                else
                                {
                                    assembly_ref.Name = "";
                                }
                                if (assembly_ref.CultureStringIndex != 0)
                                {
                                    assembly_ref.Culture = ReadStringByIndex(assembly_ref.CultureStringIndex);
                                }
                                else
                                {
                                    assembly_ref.Culture = "";
                                }

                                // Get Public Key
                                save_pos = file.Position;
                                assembly_ref.PublicKeyOffset = metadata.StreamHeaders[blob_table_index].Offset + assembly_ref.PublicKeyOrToken;
                                file.Seek(assembly_ref.PublicKeyOffset, SeekOrigin.Begin);
                                assembly_ref.PublicKey = ReadPublicKeyToken((assembly_ref.Flags & 1) != 0);
                                file.Seek(save_pos, SeekOrigin.Begin);

                                references.Add(assembly_ref);
                                break;
                            case 36: // AssemblyRefProcessor
                                file.Read(buffer, 0, 4); // Processor
                                file.Read(buffer, 0, size_assembly_ref_index); // AssemblyRef
                                break;
                            case 37: // AssemblyRefOS
                                file.Read(buffer, 0, 4); // OSPlatformId
                                file.Read(buffer, 0, 4); // OSMajorVersion
                                file.Read(buffer, 0, 4); // OSMinorVersion
                                file.Read(buffer, 0, size_assembly_ref_index); // AssemblyRef
                                break;
                            case 38: // File
                                file.Read(buffer, 0, 4); // Flags
                                ReadStringIndex(); // Name
                                ReadBlobIndex(); // HashValue
                                break;
                            case 39: // Exported Type
                                file.Read(buffer, 0, 4); // Flags
                                file.Read(buffer, 0, size_type_def_index); // TypeDefId
                                ReadStringIndex(); // TypeName
                                ReadStringIndex(); // TypeNamespace
                                file.Read(buffer, 0, size_implementation); // Implementation
                                break;
                            case 40: // ManifestResource
                                file.Read(buffer, 0, 4); // Offset
                                file.Read(buffer, 0, 4); // Flags
                                ReadStringIndex(); // Name
                                file.Read(buffer, 0, size_implementation); // Implementation
                                break;
                            case 41:
                                file.Read(buffer, 0, size_type_def_index); // NestedClass
                                file.Read(buffer, 0, size_type_def_index); // EncodingClass
                                break;
                        }
                    }
                }
            }
        }
Esempio n. 33
0
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name of resource</param>
		/// <param name="asmRef">Assembly reference</param>
		/// <param name="flags">Resource flags</param>
		public AssemblyLinkedResource(UTF8String name, AssemblyRef asmRef, ManifestResourceAttributes flags)
			: base(name, flags) {
			if (asmRef == null)
				throw new ArgumentNullException("asmRef");
			this.asmRef = asmRef;
		}
Esempio n. 34
0
			public AssemblyRefInfo(AssemblyRef asmRef) {
				this.AssemblyRef = asmRef;
				this.OrigName = asmRef.Name;
				this.OrigPublicKeyOrToken = asmRef.PublicKeyOrToken;
			}
Esempio n. 35
0
 /// <summary>
 /// Make an AssemblyRef descriptor for this Assembly
 /// </summary>
 /// <returns>AssemblyRef descriptor for this Assembly</returns>
 public AssemblyRef MakeRefOf()
 {
     if (refOf == null)
     {
         refOf = new AssemblyRef(name, majorVer, minorVer, buildNo, revisionNo,
             flags, publicKey, culture, null);
     }
     return refOf;
 }
Esempio n. 36
0
		internal SystemClass(PrimitiveType eType, AssemblyRef paren, MetaData md)
			: base("System",eType.GetName(),md) {
				elemType = eType;
				parent = paren;
			}
Esempio n. 37
0
 internal static AssemblyRef ReadAssemblyRef(PEReader buff)
 {
     buff.SetElementPosition(MDTable.Assembly, 1);
     HashAlgorithmType hAlg = (HashAlgorithmType)buff.ReadUInt32();
     ushort majVer = buff.ReadUInt16();
     ushort minVer = buff.ReadUInt16();
     ushort bldNo = buff.ReadUInt16();
     ushort revNo = buff.ReadUInt16();
     uint flags = buff.ReadUInt32();
     byte[] pKey = buff.GetBlob();
     string name = buff.GetString();
     string cult = buff.GetString();
     AssemblyRef assemRef;
     if (name.ToLower() == "mscorlib")
     {
         assemRef = MSCorLib.mscorlib;
         assemRef.AddVersionInfo(majVer, minVer, bldNo, revNo);
         if (pKey.Length > 8) assemRef.AddKey(pKey);
         else assemRef.AddKeyToken(pKey);
         assemRef.AddCulture(cult);
         assemRef.SetFlags(flags);
     }
     else
     {
         assemRef = new AssemblyRef(name, majVer, minVer, bldNo, revNo, flags, pKey, cult, null);
     }
     //AssemblyRef assemRef = new AssemblyRef(name,majVer,minVer,bldNo,revNo,flags,pKey,cult,null);
     assemRef.ReadAsDef();
     return assemRef;
 }
Esempio n. 38
0
 public void Write(ISyntaxHighlightOutput output, ILanguage language, AssemblyRef asmRef, bool showToken)
 {
     output.Write(NameUtils.CleanIdentifier(asmRef.Name), TextTokenKind.Text);
     WriteToken(output, asmRef, showToken);
 }
Esempio n. 39
0
 public static ITextOutput Write(ITextOutput output, AssemblyRef r, Language language)
 {
     output.Write(UIUtils.CleanUpIdentifier(r.Name), TextTokenType.Text);
     r.MDToken.WriteSuffixString(output);
     return(output);
 }
Esempio n. 40
0
 /// <summary>
 /// Writes an assembly reference
 /// </summary>
 /// <param name="output">Output</param>
 /// <param name="decompiler">Decompiler</param>
 /// <param name="asmRef">Assembly reference</param>
 /// <param name="showToken">true to write tokens</param>
 public void Write(ITextColorWriter output, IDecompiler decompiler, AssemblyRef asmRef, bool showToken)
 {
     output.Write(BoxedTextColor.Text, NameUtilities.CleanIdentifier(asmRef.Name));
     WriteToken(output, asmRef, showToken);
 }
Esempio n. 41
0
 public virtual FileTreeNodeFilterResult GetResult(AssemblyRef asmRef)
 {
     return(new FileTreeNodeFilterResult());
 }
		public ClassSig Type(string ns, string name, AssemblyRef asmRef) {
			return (ClassSig)Type(false, ns, name, asmRef);
		}
Esempio n. 43
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="alias"></param>
 /// <param name="targetAssembly"></param>
 public PdbAliasAssemblyReference(string alias, AssemblyRef targetAssembly)
 {
     Alias          = alias;
     TargetAssembly = targetAssembly;
 }
Esempio n. 44
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="alias"></param>
 /// <param name="targetAssembly"></param>
 /// <param name="targetNamespace"></param>
 public PdbAliasAssemblyNamespace(string alias, AssemblyRef targetAssembly, string targetNamespace)
 {
     Alias           = alias;
     TargetAssembly  = targetAssembly;
     TargetNamespace = targetNamespace;
 }
Esempio n. 45
0
 static bool IsAssemblyRef(AssemblyRef asmRef, UTF8String name, PublicKeyToken token)
 {
     if (asmRef.Name != name)
         return false;
     var pkot = asmRef.PublicKeyOrToken;
     if (pkot == null)
         return false;
     return token.Equals(pkot.Token);
 }
 public AssemblyReferenceNodeImpl(ITreeNodeGroup treeNodeGroup, ModuleDef asmRefOwnerModule, AssemblyRef assemblyRef)
 {
     TreeNodeGroup          = treeNodeGroup;
     this.asmRefOwnerModule = new WeakReference(asmRefOwnerModule);
     // Make sure we don't hold on to the original reference since it could prevent GC of the
     // owner module.
     AssemblyRef     = assemblyRef.ToAssemblyRef();
     AssemblyRef.Rid = assemblyRef.Rid;
 }
		TypeDef Resolve(AssemblyRef asmRef, TypeRef typeRef) {
			var asm = ownerModule.Assembly;
			if (asm == null)
				return null;
			if (asmRef.FullName != asm.GetFullNameWithPublicKey() && asmRef.FullName != asm.GetFullNameWithPublicKeyToken())
				return null;
			var td = typeRef.Resolve();
			return td != null && td.Module == ownerModule ? td : null;
		}
Esempio n. 48
0
 /// <summary>
 /// Add an external assembly to this PEFile (.assembly extern)
 /// </summary>
 /// <param name="assemName">the external assembly name</param>
 /// <returns>a descriptor for this external assembly</returns>
 public AssemblyRef AddExternAssembly(string assemName) {
   if (assemName.CompareTo(mscorlibName) == 0) return metaData.mscorlib;
   AssemblyRef anAssem = new AssemblyRef(metaData,assemName);
   metaData.AddToTable(MDTable.AssemblyRef,anAssem);
   // Console.WriteLine("Adding assembly " + assemName);
   return anAssem;
 }
Esempio n. 49
0
        FrameworkKind GetFrameworkKind_AssemblyRefs(ModuleDef module, string frameworkName, out Version version)
        {
            AssemblyRef mscorlibRef      = null;
            AssemblyRef systemRuntimeRef = null;
            // ASP.NET Core *.Views assemblies don't have a TFM attribute, so grab the .NET Core version from an ASP.NET Core asm ref
            AssemblyRef aspNetCoreRef = null;

            foreach (var asmRef in module.GetAssemblyRefs())
            {
                var name = asmRef.Name;
                if (name == mscorlibName)
                {
                    if (asmRef.Version != invalidMscorlibVersion)
                    {
                        if (mscorlibRef == null || asmRef.Version > mscorlibRef.Version)
                        {
                            mscorlibRef = asmRef;
                        }
                    }
                }
                else if (name == systemRuntimeName)
                {
                    if (systemRuntimeRef == null || asmRef.Version > systemRuntimeRef.Version)
                    {
                        systemRuntimeRef = asmRef;
                    }
                }
                else if (name == netstandardName)
                {
                    if (!dotNetCorePathProvider.HasDotNetCore)
                    {
                        version = null;
                        return(FrameworkKind.DotNetFramework4);
                    }
                    version = null;
                    return(FrameworkKind.Unknown);
                }
                else if (StartsWith(name, aspNetCoreName))
                {
                    if (aspNetCoreRef == null || asmRef.Version > aspNetCoreRef.Version)
                    {
                        aspNetCoreRef = asmRef;
                    }
                }
            }

            if (systemRuntimeRef != null)
            {
                // - .NET Core:
                //		1.0: System.Runtime, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.1: System.Runtime, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		2.0: System.Runtime, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		2.1: System.Runtime, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		2.2: System.Runtime, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		3.0: System.Runtime, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                // - .NET Standard:
                //		1.0: System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.1: System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.2: System.Runtime, Version=4.0.10.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.3: System.Runtime, Version=4.0.20.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.4: System.Runtime, Version=4.0.20.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		1.5: System.Runtime, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
                //		2.0: <it has no System.Runtime ref, just a netstandard.dll ref>
                if (frameworkName != TFM_netstandard)
                {
                    if (module.IsClr40Exactly && systemRuntimeRef.Version >= minSystemRuntimeNetCoreVersion)
                    {
                        version = aspNetCoreRef?.Version;
                        return(FrameworkKind.DotNetCore);
                    }
                }
            }

            version = null;
            if (mscorlibRef != null)
            {
                // It can't be Unity since we checked that before this method was called.
                // It can't be .NET Core since it uses System.Runtime.

                if (mscorlibRef.Version.Major >= 4)
                {
                    return(FrameworkKind.DotNetFramework4);
                }

                // If it's an exe and it's net20-net35, return that
                if ((module.Characteristics & Characteristics.Dll) == 0)
                {
                    return(FrameworkKind.DotNetFramework2);
                }

                // It's a net20-net35 dll, but it could be referenced by a net4x asm so we
                // can't return net20-net35.
            }

            return(FrameworkKind.Unknown);
        }
Esempio n. 50
0
 /// <summary>
 /// Add a managed resource from another assembly.
 /// </summary>
 /// <param name="resName">The name of the resource</param>
 /// <param name="assem">The assembly where the resource is</param>
 /// <param name="isPublic">Access for the resource</param>
 public void AddExternalManagedResource (string resName, AssemblyRef assem, uint flags) {
   resources.Add (new ManifestResource (resName, flags, assem));
 }
Esempio n. 51
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="assembly">Target assembly</param>
 /// <param name="namespace">Namespace</param>
 public NamespaceReference(IAssembly assembly, string @namespace)
 {
     Assembly  = assembly.ToAssemblyRef();
     Namespace = @namespace;
 }
Esempio n. 52
0
 public void Find()
 {
     resource      = FindCsvmResource();
     vmAssemblyRef = FindVmAssemblyRef();
 }
Esempio n. 53
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TypeRef"/> class.
 /// </summary>
 /// <param name="assembly">The belonging assembly of this type reference, or <c>null</c> if it is mscorlib.</param>
 /// <param name="name">The value of <see cref="Type.FullName"/>, or <c>null</c> if referring type is <see cref="Object"/>.</param>
 public TypeRef(AssemblyRef assembly, String name)
     : this()
 {
     this.Assembly = assembly;
     this.Name = name;
 }
		public ValueTypeSig ValueType(string ns, string name, AssemblyRef asmRef) {
			return (ValueTypeSig)Type(true, ns, name, asmRef);
		}
Esempio n. 55
0
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="module">The owner module</param>
		/// <param name="corLibAssemblyRef">Corlib assembly reference or <c>null</c> if a default
		/// assembly reference should be created</param>
		public CorLibTypes(ModuleDef module, AssemblyRef corLibAssemblyRef) {
			this.module = module;
			this.corLibAssemblyRef = corLibAssemblyRef ?? CreateCorLibAssemblyRef();
			Initialize();
		}
Esempio n. 56
0
        public Tabels(PEFile p)
        {
            //Init
            this.r = p.MetadataReader;

            //Read all of the tabels
            ModuleTabel           = new List <Module>();
            TypeRefTabel          = new List <TypeRef>();
            TypeDefTabel          = new List <TypeDef>();
            FieldTabel            = new List <Field>();
            MethodTabel           = new List <Method>();
            ParmTabel             = new List <Param>();
            InterfaceImplTable    = new List <InterfaceImpl>();
            MemberRefTabelRow     = new List <MemberRef>();
            ConstantTabel         = new List <Constant>();
            CustomAttributeTabel  = new List <CustomAttribute>();
            FieldMarshalTabel     = new List <FieldMarshal>();
            DeclSecurityTabel     = new List <DeclSecurity>();
            ClassLayoutTabel      = new List <ClassLayout>();
            FieldLayoutTabel      = new List <FieldLayout>();
            StandAloneSigTabel    = new List <StandAloneSig>();
            EventMapTabel         = new List <EventMap>();
            EventTabel            = new List <Event>();
            PropertyMapTabel      = new List <PropertyMap>();
            PropertyTabel         = new List <PropertyTabel>();
            MethodSemanticsTabel  = new List <MethodSemantics>();
            MethodImplTabel       = new List <MethodImpl>();
            ModuleRefTabel        = new List <ModuleRef>();
            TypeSpecTabel         = new List <TypeSpec>();
            ImplMapTabel          = new List <ImplMap>();
            FieldRVATabel         = new List <FieldRVA>();
            AssemblyTabel         = new List <Assembly>();
            AssemblyRefTabel      = new List <AssemblyRef>();
            FileTable             = new List <File>();
            ExportedTypeTable     = new List <ExportedType>();
            ManifestResourceTable = new List <ManifestResource>();
            NestedClassTable      = new List <NestedClass>();
            GenericParamTable     = new List <GenericParam>();
            MethodSpecTable       = new List <MethodSpec>();

            int a = 0;

            //Read module Tabel (if any)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Module) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Module();
                    m.Read(r);
                    ModuleTabel.Add(m);
                }
                a++;
            }
            //Read TypeRef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeRef();
                    m.Read(r);
                    TypeRefTabel.Add(m);
                }
                a++;
            }
            //Read TypeDef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeDef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeDef();
                    m.Read(r);
                    TypeDefTabel.Add(m);
                }
                a++;
            }
            //Read Field Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Field) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Field();
                    m.Read(r);
                    FieldTabel.Add(m);
                }
                a++;
            }
            //Read Method tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Method) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Method();
                    m.Read(r);
                    MethodTabel.Add(m);
                }
                a++;
            }
            //Read Parm Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Param) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Param();
                    m.Read(r);
                    ParmTabel.Add(m);
                }
                a++;
            }
            //Read interfaceimpl Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.InterfaceImpl) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new InterfaceImpl();
                    m.Read(r);
                    InterfaceImplTable.Add(m);
                }
                a++;
            }
            //Read MemberRef tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MemberRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MemberRef();
                    m.Read(r);
                    MemberRefTabelRow.Add(m);
                }
                a++;
            }
            //Read Constant tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Constant) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Constant();
                    m.Read(r);
                    ConstantTabel.Add(m);
                }
                a++;
            }
            //Read CustomAttribute tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.CustomAttribute) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new CustomAttribute();
                    m.Read(r);
                    CustomAttributeTabel.Add(m);
                }
                a++;
            }
            //Read FieldMarshal tabel (Please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldMarshal) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldMarshal();
                    m.Read(r);
                    FieldMarshalTabel.Add(m);
                }
                a++;
            }
            //Read DeclSecurity tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.DeclSecurity) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new DeclSecurity();
                    m.Read(r);
                    DeclSecurityTabel.Add(m);
                }
                a++;
            }
            //Read ClassLayout tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ClassLayout) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ClassLayout();
                    m.Read(r);
                    ClassLayoutTabel.Add(m);
                }
                a++;
            }
            //Read FieldLayout tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldLayout) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldLayout();
                    m.Read(r);
                    FieldLayoutTabel.Add(m);
                }
                a++;
            }
            //Read StandAloneSig tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.StandAloneSig) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new StandAloneSig();
                    m.Read(r);
                    StandAloneSigTabel.Add(m);
                }
                a++;
            }
            //Read EventMap tabel (please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.EventMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new EventMap();
                    m.Read(r);
                    EventMapTabel.Add(m);
                }
                a++;
            }
            //Read event tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Event) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Event();
                    m.Read(r);
                    EventTabel.Add(m);
                }
                a++;
            }
            //Read Property Map tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.PropertyMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new PropertyMap();
                    m.Read(r);
                    PropertyMapTabel.Add(m);
                }
                a++;
            }
            //Read Property tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Property) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new PropertyTabel();
                    m.Read(r);
                    PropertyTabel.Add(m);
                }
                a++;
            }
            //Read MethodSemantics  tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSemantics) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodSemantics();
                    m.Read(r);
                    MethodSemanticsTabel.Add(m);
                }
                a++;
            }
            //Read MethodImpl tabel (Please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodImpl) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodImpl();
                    m.Read(r);
                    MethodImplTabel.Add(m);
                }
                a++;
            }
            //Read ModuleRef tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ModuleRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ModuleRef();
                    m.Read(r);
                    ModuleRefTabel.Add(m);
                }
                a++;
            }
            //Read TypeSpec tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeSpec) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeSpec();
                    m.Read(r);
                    TypeSpecTabel.Add(m);
                }
                a++;
            }
            //Read ImplMap tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ImplMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ImplMap();
                    m.Read(r);
                    ImplMapTabel.Add(m);
                }
                a++;
            }
            //Read FieldRVA  tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldRVA) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldRVA();
                    m.Read(r);
                    FieldRVATabel.Add(m);
                }
                a++;
            }
            //Read Assembly tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Assembly) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Assembly();
                    m.Read(r);
                    AssemblyTabel.Add(m);
                }
                a++;
            }

            //Read ignored tabels (These never should be present!)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyProcessor) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var proc = r.ReadUInt32();
                }
                a++;
            }
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyOS) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 11; //Test please
                }
                a++;
            }
            //Read AssemblyRef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new AssemblyRef();
                    m.Read(r);
                    AssemblyRefTabel.Add(m);
                }
                a++;
            }
            //Read AssemblyRefProcessor Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefProcessor) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 8; //Test please
                }
                a++;
            }
            //Read AssemblyRefOS Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefOS) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 16; //Test please
                }
                a++;
            }
            //Read File Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.File) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new File();
                    m.Read(r);
                    FileTable.Add(m);
                }
                a++;
            }
            //Read ExportedType Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ExportedType) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ExportedType();
                    m.Read(r);
                    ExportedTypeTable.Add(m);
                }
                a++;
            }
            //Read ManifestResource Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ManifestResource) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ManifestResource();
                    m.Read(r);
                    ManifestResourceTable.Add(m);
                }
                a++;
            }
            //Read NestedClass Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.NestedClass) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new NestedClass();
                    m.Read(r);
                    NestedClassTable.Add(m);
                }
                a++;
            }
            //Read GenericParam Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.GenericParam) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new GenericParam();
                    m.Read(r);
                    GenericParamTable.Add(m);
                }
                a++;
            }
            //Read MethodSpec Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSpec) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodSpec();
                    m.Read(r);
                    MethodSpecTable.Add(m);
                }
                a++;
            }
        }
Esempio n. 57
0
		public ManifestResource(string name, uint flags, AssemblyRef assemRef) 
		{
			InitResource (name, flags);
			rRef = assemRef;
		}
 public virtual DocumentTreeNodeFilterResult GetResult(AssemblyRef asmRef) => this.filter.GetResult(asmRef);
Esempio n. 59
0
 public virtual FileTreeNodeFilterResult GetResult(AssemblyRef asmRef) => new FileTreeNodeFilterResult(FilterType.Hide, false);
Esempio n. 60
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="targetAssembly"></param>
 /// <param name="targetNamespace"></param>
 public PdbImportAssemblyNamespace(AssemblyRef targetAssembly, string targetNamespace)
 {
     TargetAssembly  = targetAssembly;
     TargetNamespace = targetNamespace;
 }