private static MetaDataObject ResolveTypeRef(MetaDataResolver resolver, MetaDataResolver[] resolvers, MetaDataTypeReference typeRef) { MetaDataObject result = resolver.ResolveTypeRef(typeRef); int i = 0; while (result == null && i < resolvers.Length) { MetaDataResolver testResolver = resolvers[i]; i++; if (testResolver != resolver) { result = testResolver.ResolveTypeRef(typeRef); } } return(result); }
public MetaDataTypeDefinition ResolveTypeRef(MetaDataTypeReference reference) { String refName = reference.Namespace + "." + reference.Name; return(ResolveName(refName)); }
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)); } } }