public static SharpAssembly LoadFrom(string filename, bool fromGAC) { // lock the assembly object in case that the preload thread is conflicting with another lock (typeof(SharpAssembly)) { AssemblyReader read = new AssemblyReader(); read.Load(filename); SharpAssembly asm = new SharpAssembly(read, fromGAC); asm.LoadReferences(); asm.LoadNestedTypeTable(); asm.LoadAttributeTable(); asm.LoadFieldConstants(); return asm; } }
void AddProperties(SharpAssembly_ asm, TypeDef[] typeDefTable, uint index) { PropertyMap[] propertyMapTable = asm.Tables.PropertyMap; Property[] propertyTable = asm.Tables.Property; if (propertyMapTable == null || propertyTable == null) { return; } for (int i = 1; i <= propertyMapTable.GetUpperBound(0); ++i) { PropertyMap propertyMap = propertyMapTable[i]; if (propertyMap.Parent == index) { uint propertyIndexStart = propertyMap.PropertyList; // 0 means no properties if (propertyIndexStart == 0) { return; } uint propertyIndexEnd = (uint)propertyTable.GetUpperBound(0); if (i < propertyMapTable.GetUpperBound(0)) { propertyIndexEnd = propertyMapTable[i + 1].PropertyList; } for (uint j = propertyIndexStart; j < propertyIndexEnd; ++j) { IProperty newProperty = new SharpAssemblyProperty(asm, propertyTable, this, j); properties.Add(newProperty); } break; } } }
/// <summary> /// The constructor is private because the only way to construct SharpAssemblyClass objects /// is to call FromTypeRef/Def to make us of the cache /// </summary> private SharpAssemblyClass(SharpAssembly_ assembly, TypeDef[] typeDefTable, uint index) { if (assembly == null) { throw new System.ArgumentNullException("assembly"); } if (typeDefTable == null) { throw new System.ArgumentNullException("typeDefTable"); } if (index > typeDefTable.GetUpperBound(0) || index < 1) { throw new System.ArgumentOutOfRangeException("index", index, String.Format("must be between 1 and {0}!", typeDefTable.GetUpperBound(0))); } TypeDef typeDef = typeDefTable[index]; typeDefIndex = index; // store index for use in LoadMembers() declaredIn = assembly; FullyQualifiedName = GetNestedName(assembly, typeDefTable, index); // store in assembly's cache assembly.TypeDefObjects[index] = this; if (typeDef.IsFlagSet(TypeDef.FLAG_INTERFACE)) { classType = ClassType.Interface; } else if (typeDef.IsFlagSet(TypeDef.FLAG_CLASS)) { classType = ClassType.Class; } if (typeDef.Extends == 0) goto noext; SharpAssemblyClass extend = GetTypeRefOrDefClass(assembly, typeDef.Extends); if (extend == null) goto noext; if (extend.FullyQualifiedName == "System.Enum") { classType = ClassType.Enum; } else if (extend.FullyQualifiedName == "System.ValueType") { classType = ClassType.Struct; } baseTypeCollection.Add(extend); if (IsSubclassOf("System.Delegate")) classType = ClassType.Delegate; noext: InterfaceImpl[] ifaces = assembly.Tables.InterfaceImpl; if (ifaces == null) goto nointerfaces; for (int i = 1; i <= ifaces.GetUpperBound(0); ++i) { if (ifaces[i].Class == index) { SharpAssemblyClass impl = GetTypeRefOrDefClass(assembly, ifaces[i].Interface); if (impl != null) { baseTypeCollection.Add(impl); } } } nointerfaces: NestedClass[] nestedClasses = assembly.Tables.NestedClass; if (nestedClasses == null) goto nonested; for (int i = 1; i <= nestedClasses.GetUpperBound(0); ++i) { if (nestedClasses[i].EnclosingClass == index) { IClass newclass = FromTypeDef(assembly, nestedClasses[i].NestedClassIndex); innerClasses.Add(newclass); } } nonested: // Attributes ArrayList attrib = assembly.Attributes.TypeDef[index] as ArrayList; if (attrib == null) goto modifiers; AbstractAttributeSection sect = new AbstractAttributeSection(); foreach(SharpCustomAttribute customattribute in attrib) { sect.Attributes.Add(new SharpAssemblyAttribute(assembly, customattribute)); } attributes.Add(sect); modifiers: modifiers = ModifierEnum.None; if (typeDef.IsFlagSet(TypeDef.FLAG_SEALED)) { modifiers |= ModifierEnum.Sealed; } if (typeDef.IsFlagSet(TypeDef.FLAG_ABSTRACT)) { modifiers |= ModifierEnum.Abstract; } if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDPRIVATE, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.Private; } else if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDPUBLIC, TypeDef.FLAG_VISIBILITYMASK) || typeDef.IsMaskedFlagSet(TypeDef.FLAG_PUBLIC, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.Public; } else if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDASSEMBLY, TypeDef.FLAG_VISIBILITYMASK) || typeDef.IsMaskedFlagSet(TypeDef.FLAG_NOTPUBLIC, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.Internal; } else if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDFAMILY, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.Protected; } else if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDFAMORASSEM, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.ProtectedOrInternal; } else if (typeDef.IsMaskedFlagSet(TypeDef.FLAG_NESTEDFAMANDASSEM, TypeDef.FLAG_VISIBILITYMASK)) { modifiers |= ModifierEnum.Protected; modifiers |= ModifierEnum.Internal; } if (typeDef.IsFlagSet(TypeDef.FLAG_SPECIALNAME)) { modifiers |= ModifierEnum.SpecialName; } /* members are loaded on demand now if (classType != ClassType.Delegate && loadMembers) { AddMethods(assembly, typeDefTable, index); AddFields(assembly, typeDefTable, index); AddProperties(assembly, typeDefTable, index); AddEvents(assembly, typeDefTable, index); membersLoaded = true; } */ }
void AddMethods(SharpAssembly_ asm, TypeDef[] typeDefTable, uint index) { Method[] methodDefTable = asm.Tables.Method; if (methodDefTable == null) { return; } uint methodIndexStart = typeDefTable[index].MethodList; // 0 means no methods if (methodIndexStart == 0) { return; } uint methodIndexEnd = (uint)methodDefTable.GetUpperBound(0); if (index < typeDefTable.GetUpperBound(0)) { methodIndexEnd = typeDefTable[index + 1].MethodList; } for (uint i = methodIndexStart; i < methodIndexEnd; ++i) { IMethod newMethod = new SharpAssemblyMethod(asm, methodDefTable, this, i); methods.Add(newMethod); } }
void AddFields(SharpAssembly_ asm, TypeDef[] typeDefTable, uint index) { Field[] fieldTable = asm.Tables.Field; if (fieldTable == null) { return; } uint fieldIndexStart = typeDefTable[index].FieldList; // 0 means no fields if (fieldIndexStart == 0) { return; } uint fieldIndexEnd = (uint)fieldTable.GetUpperBound(0); if (index < typeDefTable.GetUpperBound(0)) { fieldIndexEnd = typeDefTable[index + 1].FieldList; } for (uint i = fieldIndexStart; i < fieldIndexEnd; ++i) { IField newField = new SharpAssemblyField(asm, fieldTable, this, i); fields.Add(newField); } }
void AddEvents(SharpAssembly_ asm, TypeDef[] typeDefTable, uint index) { EventMap[] eventMapTable = asm.Tables.EventMap; Event[] eventTable = asm.Tables.Event; if (eventMapTable == null || eventTable == null) { return; } for (int i = 1; i <= eventMapTable.GetUpperBound(0); ++i) { EventMap eventMap = eventMapTable[i]; if (eventMap.Parent == index) { uint eventIndexStart = eventMap.EventList; // 0 means no events if (eventIndexStart == 0) { return; } uint eventIndexEnd = (uint)eventTable.GetUpperBound(0); if (i < eventMapTable.GetUpperBound(0)) { eventIndexEnd = eventMapTable[i + 1].EventList; } for (uint j = eventIndexStart; j < eventIndexEnd; ++j) { IEvent newEvent = new SharpAssemblyEvent(asm, eventTable, this, j); events.Add(newEvent); } break; } } }
private static SharpAssemblyClass GetTypeRefOrDefClass(SharpAssembly_ assembly, uint cind) { uint nTable = cind & 0x03; uint nIndex = cind >> 2; switch (nTable) { case 0: // TypeDef return FromTypeDef(assembly, nIndex); case 1: // TypeRef return FromTypeRef(assembly, nIndex); default: Runtime.LoggingService.Info("GetTypeRefOrDefClass: Wrong TypeDefOrRef coded index!"); return null; } }
public static string GetNestedName(SharpAssembly_ asm, TypeDef[] typeDefTable, uint index) { uint nestedParent = asm.GetNestedTypeParent(index); if (nestedParent == 0) { return asm.Reader.GetStringFromHeap(typeDefTable[index].NSpace) + "." + asm.Reader.GetStringFromHeap(typeDefTable[index].Name); } return GetNestedName(asm, typeDefTable, nestedParent) + "+" + asm.Reader.GetStringFromHeap(typeDefTable[index].Name); }
public static string GetNestedName(SharpAssembly_ asm, TypeRef[] typeRefTable, uint index) { uint val = typeRefTable[index].ResolutionScope; int table = asm.Reader.GetCodedIndexTable(CodedIndex.ResolutionScope, ref val); switch (table) { case 2: // AssemblyRef return asm.Reader.GetStringFromHeap(typeRefTable[index].Nspace) + "." + asm.Reader.GetStringFromHeap(typeRefTable[index].Name); case 3: // TypeRef -- nested type return GetNestedName(asm, typeRefTable, val) + "+" + asm.Reader.GetStringFromHeap(typeRefTable[index].Name); default: // other token - not supported Runtime.LoggingService.Info("GetNestedName: Unsupported resolution scope!"); goto case 3; } }
public static SharpAssemblyClass[] GetAssemblyTypes(SharpAssembly_ assembly) { TypeDef[] typeDefTable = assembly.Tables.TypeDef; if (typeDefTable == null) return new SharpAssemblyClass[0]; ArrayList classes = new ArrayList(); for (uint i = 1; i <= typeDefTable.GetUpperBound(0); ++i) { try { IClass newclass = new SharpAssemblyClass(assembly, typeDefTable, i); classes.Add(newclass); } catch { Runtime.LoggingService.Info("GetAssemblyTypes: Error loading class " + i); } } return (SharpAssemblyClass[])classes.ToArray(typeof(SharpAssemblyClass)); }
/// <summary> /// Constructs a SharpAssemblyClass from an entry in the assembly's TypeRef table /// by looking in the referencing assembly's TypeDef table /// </summary> public static SharpAssemblyClass FromTypeRef(SharpAssembly_ referencingAssembly, uint index) { if (referencingAssembly.TypeRefObjects[index] as SharpAssemblyClass != null) { return (SharpAssemblyClass)referencingAssembly.TypeRefObjects[index]; } TypeRef[] typeRefTable = referencingAssembly.Tables.TypeRef; string name = referencingAssembly.Reader.GetStringFromHeap(typeRefTable[index].Name); SharpAssembly_ declaringAssembly = referencingAssembly.GetRefAssemblyFor(index); if (declaringAssembly == null) { Console.Write("FromTypeRef failed for: " + name + " declared in assembly " + referencingAssembly.Name); Runtime.LoggingService.Info(": Declaring assembly not found."); return null; } TypeDef[] typeDefTable = declaringAssembly.Tables.TypeDef; if (typeDefTable == null) { return null; } string nestedName = GetNestedName(referencingAssembly, typeRefTable, index); for (uint i = 1; i <= typeDefTable.GetUpperBound(0); ++i) { if (declaringAssembly.Reader.GetStringFromHeap(typeDefTable[i].Name) == name) { if (GetNestedName(declaringAssembly, typeDefTable, i) == nestedName) { SharpAssemblyClass newclass = FromTypeDef(declaringAssembly, i); // store new class object in assembly's cache if (newclass != null) referencingAssembly.TypeRefObjects[index] = newclass; return newclass; } } } Console.Write("FromTypeRef failed for: " + name + " declared in assembly " + referencingAssembly.Name); Runtime.LoggingService.Info(": Matching type not found for nested name: " + nestedName); return null; }
/// <summary> /// Constructs a SharpAssemblyClass from an entry in the assembly's TypeDef table /// Looks in the class cache for the assembly first /// </summary> public static SharpAssemblyClass FromTypeDef(SharpAssembly_ assembly, uint index) { if (assembly.TypeDefObjects[index] as SharpAssemblyClass != null) { SharpAssemblyClass exclass = (SharpAssemblyClass)assembly.TypeDefObjects[index]; return exclass; } return new SharpAssemblyClass(assembly, assembly.Tables.TypeDef, index); }
public SharpCustomAttribute(SharpAssembly Assembly, uint TypeIndex, uint ValueIndex) { assembly = Assembly; valueIndex = ValueIndex; memberIndex = TypeIndex; int table = assembly.Reader.GetCodedIndexTable(CodedIndex.CustomAttributeType, ref memberIndex); if (table == 3) isMemberRef = true; }