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));
}
}
}
