sharpassemblyclass.cs

全功能c#编译器

			AbstractAttributeSection sect = new AbstractAttributeSection();
			
			foreach(SharpCustomAttribute customattribute in attrib) {
				sect.Attributes.Add(new SharpAssemblyAttribute(assembly, customattribute));
			}
			
			if (attributes == null) attributes = new AttributeSectionCollection();
			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;
			}
			*/
		}
		
		uint typeDefIndex = 0;
		
		bool membersLoaded = false;
		
		void LoadMembers()
		{
			if (membersLoaded) return;
			
			SharpAssembly assembly = (SharpAssembly)declaredIn;
			TypeDef[] typeDefTable = assembly.Tables.TypeDef;
			
			methods    = new MethodCollection();
			events     = new EventCollection();
			fields     = new FieldCollection();
			properties = new PropertyCollection();
			AddMethods(assembly, typeDefTable, typeDefIndex);
			AddFields(assembly, typeDefTable, typeDefIndex);
			AddProperties(assembly, typeDefTable, typeDefIndex);
			AddEvents(assembly, typeDefTable, typeDefIndex);
			
			membersLoaded = true;
		}
		
		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(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(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;
				}
			}
		}
		
		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;
				}
			}
		}
		
		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 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);
			}
		}
		
		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 {
					Console.WriteLine("GetAssemblyTypes: Error loading class " + i);
				}
			}
			
			return (SharpAssemblyClass[])classes.ToArray(typeof(SharpAssemblyClass));
		}
		
		public override string ToString()
		{
			return FullyQualifiedName;
		}
		
		public FieldCollection Fields {
			get {
				if (!membersLoaded) LoadMembers();
				return fields;
			}
		}

		public PropertyCollection Properties {
			get {
				if (!membersLoaded) LoadMembers();
				return properties;
			}
		}

		public MethodCollection Methods {
			get {
				if (!membersLoaded) LoadMembers();
				return methods;
			}
		}

		public EventCollection Events {
			get {
				if (!membersLoaded) LoadMembers();
				return events;
			}
		}

	}
}