sharpassemblyclass.cs

SharpDevelop2.0.0 c#开发免费工具

				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.Volatile | ModifierEnum.Unsafe | ModifierEnum.Extern;
			}
			
			/* 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;
			}
			*/
		}
		
		uint typeDefIndex = 0;
		
		bool membersLoaded = false;
		
		void LoadMembers()
		{
			if (membersLoaded) return;
			
			membersLoaded = true;
			
			SA.SharpAssembly assembly = (SA.SharpAssembly)declaredIn;
			TypeDef[] typeDefTable = assembly.Tables.TypeDef;
				
			AddMethods(assembly, typeDefTable, typeDefIndex);
			AddFields(assembly, typeDefTable, typeDefIndex);
			AddProperties(assembly, typeDefTable, typeDefIndex);
			AddEvents(assembly, typeDefTable, typeDefIndex);
		}
		
		public bool IsSubclassOf(string FullName)
		{
			foreach (SharpAssemblyClass basetype in baseTypeCollection) {
				if (basetype.FullyQualifiedName == FullName) return true;
				
				if (basetype.IsSubclassOf(FullName)) return true;
			}
			
			return false;
		}
		
		private static SharpAssemblyClass GetTypeRefOrDefClass(SA.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:
					Console.WriteLine("GetTypeRefOrDefClass: Wrong TypeDefOrRef coded index!");
					return null;
			}
		}
		
		void AddEvents(SA.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) + 1;
					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;
				}
			}
		}
		
		void AddProperties(SA.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) + 1;
					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;
				}
			}
		}
		
		void AddFields(SA.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) + 1;
			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 AddMethods(SA.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) + 1;
			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);
			}
		}
		
		public static SharpAssemblyClass[] GetAssemblyTypes(SA.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 {
					Console.WriteLine("GetAssemblyTypes: Error loading class " + i);
				}
			}
			
			return (SharpAssemblyClass[])classes.ToArray(typeof(SharpAssemblyClass));
		}
		
		public override string ToString()
		{
			return FullyQualifiedName;
		}
		
		public override List<IField> Fields {
			get {
				if (!membersLoaded) LoadMembers();
				return base.Fields;
			}
		}

		public override List<IProperty> Properties {
			get {
				if (!membersLoaded) LoadMembers();
				return base.Properties;
			}
		}

		public override List<IMethod> Methods {
			get {
				if (!membersLoaded) LoadMembers();
				return base.Methods;
			}
		}

		public override List<IEvent> Events {
			get {
				if (!membersLoaded) LoadMembers();
				return base.Events;
			}
		}
	}
}