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;
 }
示例#7
0
 internal void setParent(MetaDataTypeDefinition parent)
 {
     this.parent = parent;
 }
示例#8
0
        // 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);
            }
        }
示例#9
0
 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));
            }
            }
        }