public MetaDataTypeDefinition ResolveName(String refName) { if (fDebug) { Console.Out.WriteLine("Attempting to resolve in " + this.GetHashCode() + ": " + refName); } EntryPair pair = (EntryPair)mapTable[refName]; if (pair == null) { if (fDebug) { Console.Out.WriteLine("...failed"); } return(null); } else { MetaDataTypeDefinition result = pair.Definition; if (fDebug) { ResolverEntry entry = pair.Entry; Console.Out.WriteLine("...found " + result + " in " + entry); } return(result); } }
private static MetaDataTypeDefinition ResolveName(MetaDataResolver resolver, MetaDataResolver[] resolvers, String typeName) { MetaDataTypeDefinition typeDef = resolver.ResolveName(typeName); int i = 0; while (typeDef == null && i < resolvers.Length) { MetaDataResolver testResolver = resolvers[i]; i++; if (testResolver != resolver) { typeDef = testResolver.ResolveName(typeName); } } return(typeDef); }
private static Object ExtractEnumValue(MetaDataTypeDefinition typeDef, BinaryReader reader, MetaDataResolver resolver, MetaDataResolver[] resolvers) { MetaDataField[] classFields = typeDef.Fields; for (int i = 0; i < classFields.Length; i++) { if ((classFields[i].Flags & (int)MetaDataField.FieldAttributes.Static) == 0) { if (!classFields[i].Name.Equals("value__")) { throw new MetaDataLoader.IllegalMetaDataFormatException("Found enum with non-static field " + classFields[i].Name); } return(ExtractParameter(classFields[i].Signature.FieldType, reader, resolver, resolvers)); } } throw new MetaDataLoader.IllegalMetaDataFormatException("Found enum without non-static field"); }
// Constructor Methods internal MetaDataNestedClass(MetaDataTypeDefinition nestedClass, MetaDataTypeDefinition enclosingClass) { this.nestedClass = nestedClass; this.enclosingClass = enclosingClass; }
internal void resolveReferences(MetaDataTypeDefinition parent) { this.parent = parent; }
public EntryPair(MetaDataTypeDefinition definition, ResolverEntry entry) { this.Definition = definition; this.Entry = entry; }
internal void setParent(MetaDataTypeDefinition parent) { this.parent = parent; }
// Helper Methods private int getFieldSize(Signature.Type fieldType) { switch (fieldType.ElementType) { case ElementTypes.VOID: return(0); case ElementTypes.BOOLEAN: case ElementTypes.I1: case ElementTypes.U1: return(1); case ElementTypes.CHAR: case ElementTypes.I2: case ElementTypes.U2: return(2); case ElementTypes.I4: case ElementTypes.U4: case ElementTypes.R4: return(4); case ElementTypes.I8: case ElementTypes.U8: case ElementTypes.R8: return(8); case ElementTypes.OBJECT: case ElementTypes.STRING: case ElementTypes.FNPTR: case ElementTypes.CLASS: case ElementTypes.PTR: case ElementTypes.BYREF: case ElementTypes.U: case ElementTypes.I: return(machineIntSize); case ElementTypes.TYPEDBYREF: return(2 * machineIntSize); case ElementTypes.VALUETYPE: { MetaDataObject classObject = fieldType.ClassObject; if (!(classObject is MetaDataTypeDefinition)) { return(-1); } MetaDataTypeDefinition typedef = (MetaDataTypeDefinition)classObject; if ((typedef.Flags & TypeAttributes.Interface) != 0 || (typedef.Flags & TypeAttributes.Abstract) != 0) { return(-1); } int classSize = 0; int packSize = 0; if (typedef.ClassLayout != null) { classSize = typedef.ClassLayout.ClassSize; packSize = typedef.ClassLayout.PackingSize; } int instanceFieldSize = 0; if ((typedef.Flags & TypeAttributes.ExplicitLayout) != 0) { foreach (MetaDataField mdField in typedef.Fields) { if ((mdField.Flags & (int)MetaDataField.FieldAttributes.Static) == 0) { Signature.Type nestedFieldType = ((SignatureField)mdField.Signature).FieldType; int fieldSize = this.getFieldSize(nestedFieldType); int offset = mdField.Layout.Offset; int fieldEnd = fieldSize + offset; if (fieldEnd > instanceFieldSize) { instanceFieldSize = fieldEnd; } } } } else { foreach (MetaDataField mdField in typedef.Fields) { if ((mdField.Flags & (int)MetaDataField.FieldAttributes.Static) == 0) { Signature.Type nestedFieldType = ((SignatureField)mdField.Signature).FieldType; int fieldSize = this.getFieldSize(nestedFieldType); if (fieldSize == -1) { return(-1); } if (packSize > 1) { int delta = instanceFieldSize % packSize; if (delta > 0) { instanceFieldSize += packSize - delta; } } instanceFieldSize += fieldSize; } } } if (instanceFieldSize > classSize) { return(instanceFieldSize); } else if (classSize > 0) { return(classSize); } else { return(1); } } case ElementTypes.ARRAY: { int elementCount = 1; uint[] lowerBounds = fieldType.LowerBounds; uint[] upperBounds = fieldType.UpperBounds; int rank = upperBounds.Length; for (int i = 0; i < rank; i++) { int dimSize = (int)(upperBounds[i] - lowerBounds[i]); if (dimSize == 0) { // Must be an array of pointers to other arrays return(elementCount * machineIntSize); } else { elementCount *= dimSize; } } int elementSize = this.getFieldSize(fieldType.TypeObject); return(elementCount * elementSize); } case ElementTypes.CMOD_REQD: case ElementTypes.CMOD_OPT: return(this.getFieldSize(fieldType.TypeObject)); case ElementTypes.PINNED: return(this.getFieldSize(fieldType.TypeObject)); case ElementTypes.SZARRAY: // Should be machine dependent! return(4); case ElementTypes.SENTINEL: case ElementTypes.END: default: return(-1); } }
internal void resolveReferences(MetaDataTypeDefinition enclosingClass) { this.enclosingClass = enclosingClass; }
private static Object ExtractParameter(Signature.Type type, BinaryReader reader, MetaDataResolver resolver, MetaDataResolver[] resolvers) { switch (type.ElementType) { case ElementTypes.VALUETYPE: { MetaDataObject classObject = type.ClassObject; if (classObject is MetaDataTypeReference) { MetaDataTypeReference classReference = (MetaDataTypeReference)classObject; MetaDataObject resolvedObject = ResolveTypeRef(resolver, resolvers, classReference); if (resolvedObject is MetaDataTypeDefinition) { classObject = resolvedObject; } } if (classObject is MetaDataTypeReference) { // We will simply assume it is an I4 enum Console.Out.WriteLine("====>>> WARNING: Making I4 enum assumption for " + classObject); return(reader.ReadInt32()); } else if (classObject is MetaDataTypeDefinition) { MetaDataTypeDefinition classDef = (MetaDataTypeDefinition)classObject; MetaDataObject superClass = classDef.Extends; String superName; if (superClass is MetaDataTypeDefinition) { superName = ((MetaDataTypeDefinition)superClass).FullName; } else if (superClass is MetaDataTypeReference) { superName = ((MetaDataTypeReference)superClass).FullName; } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Unexpected superclass of valuetype: " + superClass); } if (!superName.Equals("System.Enum")) { throw new MetaDataLoader.IllegalMetaDataFormatException("Found valuetype that wasn't an Enum"); } return(ExtractEnumValue(classDef, reader, resolver, resolvers)); } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Unexpected valuetype class: " + classObject); } } case ElementTypes.CLASS: { MetaDataObject classObject = type.ClassObject; if (classObject is MetaDataTypeReference) { MetaDataTypeReference classReference = (MetaDataTypeReference)classObject; MetaDataObject resolvedObject = ResolveTypeRef(resolver, resolvers, classReference); if (resolvedObject is MetaDataTypeDefinition) { classObject = resolvedObject; } } String className; if (classObject is MetaDataTypeReference) { className = ((MetaDataTypeReference)classObject).FullName; } else if (classObject is MetaDataTypeDefinition) { className = ((MetaDataTypeDefinition)classObject).FullName; } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Unexpected class: " + classObject); } if (className.Equals("System.String")) { return(ExtractString(reader)); } else if (className.Equals("System.Object")) { goto case ElementTypes.OBJECT; } else if (className.Equals("System.Type")) { return(ExtractString(reader)); } if (!(classObject is MetaDataTypeDefinition)) { throw new MetaDataLoader.IllegalMetaDataFormatException("Cannot determine whether the following is an array: " + classObject); } MetaDataObject superClass = ((MetaDataTypeDefinition)classObject).Extends; Console.WriteLine("class is " + classObject); throw new Exception("Not implemented: object encoding an array"); } case ElementTypes.OBJECT: case (ElementTypes)SerializationTypes.TAGGED_OBJECT: { SerializationTypes objectType = (SerializationTypes) reader.ReadByte(); switch (objectType) { case SerializationTypes.ENUM: { String typeName = ExtractString(reader); // Some Stringified type names include a bunch of // information past the type, none of which we // are concerned about for the moment. int nameEnd = typeName.IndexOf(','); if (nameEnd >= 0) { typeName = typeName.Substring(0, nameEnd); } // A type defined within another type has a "+" // as the separator. Convert it to ".", which is // the convention the rest of the reader uses. typeName = typeName.Replace('+', '.'); MetaDataTypeDefinition typeDef = ResolveName(resolver, resolvers, typeName); if (typeDef == null) { throw new Exception("No typedef for " + typeName); } return(ExtractEnumValue(typeDef, reader, resolver, resolvers)); } case SerializationTypes.TYPE: { return(ExtractValue((ElementTypes)objectType, reader)); } default: { throw new Exception("Found OBJECT type with type " + objectType); } } } case ElementTypes.SZARRAY: { return(ExtractArrayValue(type.TypeObject, reader, resolver, resolvers)); } default: { return(ExtractValue(type.ElementType, reader)); } } }