/// <summary>
        /// Initialises a new instance of the MethodImplMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public MethodImplMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfMethodDefOrRefIndex = resolver.GetSizeOfIndex(CodedIndexes.MethodDefOrRef);
            byte sizeOfTypeDefIndex        = indexDetails.GetSizeOfIndex(MetadataTables.TypeDef);

            _class      = new Index(contents, offset, sizeOfTypeDefIndex);
            _methodBody = resolver.Resolve(CodedIndexes.MethodDefOrRef,
                                           FieldReader.ToUInt32(contents, offset.Shift(sizeOfMethodDefOrRefIndex), sizeOfMethodDefOrRefIndex)
                                           );
            _methodDeclaration = resolver.Resolve(CodedIndexes.MethodDefOrRef,
                                                  FieldReader.ToUInt32(contents, offset.Shift(sizeOfMethodDefOrRefIndex), sizeOfMethodDefOrRefIndex)
                                                  );
        }
        /// <summary>
        /// Initialises a new instance of the CustomAttributeMetadataTableRow
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public CustomAttributeMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            int  hasCustomAttributeIndexSize = resolver.GetSizeOfIndex(CodedIndexes.HasCustomAttribute);
            int  customAttributeIndexSize    = resolver.GetSizeOfIndex(CodedIndexes.CustomAttributeType);
            byte sizeOfBlobIndex             = indexDetails.GetSizeOfBlobIndex();

            this.FileOffset = offset;

            _parentIndex = resolver.Resolve(
                CodedIndexes.HasCustomAttribute,
                FieldReader.ToUInt32(contents, offset.Shift(hasCustomAttributeIndexSize), hasCustomAttributeIndexSize)
                );
            _typeIndex = resolver.Resolve(CodedIndexes.CustomAttributeType,
                                          FieldReader.ToUInt32(contents, offset.Shift(customAttributeIndexSize), customAttributeIndexSize)
                                          );
            _value = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
        }
        /// <summary>
        /// Initialises a new instance of the MethodSpecMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public MethodSpecMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfCodedIndex = resolver.GetSizeOfIndex(CodedIndexes.MethodDefOrRef);
            byte sizeOfBlobIndex  = indexDetails.GetSizeOfBlobIndex();

            _method = resolver.Resolve(CodedIndexes.MethodDefOrRef,
                                       FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
                                       );
            _instantiation = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Initialises a new instance of the GenericParamConstraintMetadataTableRow class
        /// </summary>
        /// <param name="stream">The stream containing the metadata</param>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public GenericParamConstraintMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            FileOffset = offset;

            int  sizeOfCodedIndex        = resolver.GetSizeOfIndex(CodedIndexes.TypeDefOrRef);
            byte sizeOfGenericParamIndex = indexDetails.GetSizeOfIndex(MetadataTables.GenericParam);

            _owner      = new Index(contents, offset, sizeOfGenericParamIndex);
            _constraint = resolver.Resolve(
                CodedIndexes.TypeDefOrRef,
                FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
                );
        }
        /// <summary>
        /// Initialises a new instance of the MethodSemanticsMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public MethodSemanticsMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfCodedIndex     = resolver.GetSizeOfIndex(CodedIndexes.HasSemantics);
            byte sizeOfMethodDefIndex = indexDetails.GetSizeOfIndex(MetadataTables.MethodDef);

            _semantics   = (MethodSemanticsAttributes)BitConverter.ToUInt16(contents, offset.Shift(2));
            _method      = new Index(contents, offset, sizeOfMethodDefIndex);
            _association = resolver.Resolve(CodedIndexes.HasSemantics,
                                            FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
                                            );
        }
        /// <summary>
        /// Initialises a new instance of the TypeRefMetadataTableRow class
        /// </summary>
        /// <param name="contents">The file contents</param>
        /// <param name="offset">The offset for this entry</param>
        public TypeRefMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfCodedIndex  = resolver.GetSizeOfIndex(CodedIndexes.ResolutionScope);
            byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();

            _resolutionScope = resolver.Resolve(CodedIndexes.ResolutionScope,
                                                FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
                                                );
            _nameIndex      = new StringIndex(contents, sizeOfStringIndex, offset);
            _namespaceIndex = new StringIndex(contents, sizeOfStringIndex, offset);
        }
        /// <summary>
        /// Initialises a new instance of the FieldMarshalMEtadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public FieldMarshalMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfHasFieldMarshalIndex = resolver.GetSizeOfIndex(CodedIndexes.HasFieldMarshall);
            byte sizeOfBlobIndex            = indexDetails.GetSizeOfBlobIndex();

            _parentIndex = resolver.Resolve(
                CodedIndexes.HasFieldMarshall,
                FieldReader.ToUInt32(contents, offset.Shift(sizeOfHasFieldMarshalIndex), sizeOfHasFieldMarshalIndex)
                );
            _nativeTypeIndex = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
        }
        /// <summary>
        /// Initialises a new instance of the EventMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public EventMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  typeDefOrRefIndexSize = resolver.GetSizeOfIndex(CodedIndexes.TypeDefOrRef);
            byte sizeOfStringIndex     = indexDetails.GetSizeOfStringIndex();

            _eventFlags     = (EventAttributes)BitConverter.ToUInt16(contents, offset.Shift(2));
            _nameIndex      = new StringIndex(contents, sizeOfStringIndex, offset);
            _eventTypeIndex = resolver.Resolve(
                CodedIndexes.TypeDefOrRef,
                FieldReader.ToUInt32(contents, offset.Shift(typeDefOrRefIndexSize), typeDefOrRefIndexSize)
                );
        }
        /// <summary>
        /// Initialises a new instance of the GenericParamMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public GenericParamMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfCodeIndex   = resolver.GetSizeOfIndex(CodedIndexes.TypeOrMethodDef);
            byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();

            _number     = FieldReader.ToUInt16(contents, offset.Shift(2));
            _flags      = (GenericParamAttributes)FieldReader.ToUInt16(contents, offset.Shift(2));
            _ownerIndex = resolver.Resolve(CodedIndexes.TypeOrMethodDef,
                                           FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodeIndex), sizeOfCodeIndex)
                                           );
            _nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
        }
        /// <summary>
        /// Initialises a new instance of the DeclSecurityMetadataTableRow
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the this row</param>
        public DeclSecurityMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  declSecurityIndexSize = resolver.GetSizeOfIndex(CodedIndexes.HasDeclSecurity);
            byte sizeOfBlobIndex       = indexDetails.GetSizeOfBlobIndex();

            _action      = BitConverter.ToUInt16(contents, offset.Shift(2));
            _parentIndex = resolver.Resolve(
                CodedIndexes.HasDeclSecurity,
                FieldReader.ToUInt32(contents, offset.Shift(declSecurityIndexSize), declSecurityIndexSize)
                );
            _permissionSet = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
        }
        /// <summary>
        /// Initialises a new instance of the MemberRefMetadataTableRow
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of this row</param>
        public MemberRefMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfMemberRefParentIndex = resolver.GetSizeOfIndex(CodedIndexes.MemberRefParent);
            byte sizeOfStringIndex          = indexDetails.GetSizeOfStringIndex();
            byte sizeOfBlobIndex            = indexDetails.GetSizeOfBlobIndex();

            _class = resolver.Resolve(CodedIndexes.MemberRefParent,
                                      FieldReader.ToUInt32(contents, offset.Shift(sizeOfMemberRefParentIndex), sizeOfMemberRefParentIndex)
                                      );
            _name      = new StringIndex(contents, sizeOfStringIndex, offset);
            _signiture = new BlobIndex(sizeOfBlobIndex, contents, Reflection.Signatures.Signatures.MethodDef, offset);
        }
        /// <summary>
        /// Initialises a new instance of the ManifestResourceMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of this current row</param>
        public ManifestResourceMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfImplementationIndex = resolver.GetSizeOfIndex(CodedIndexes.Implementation);
            byte sizeOfStringIndex         = indexDetails.GetSizeOfStringIndex();

            _offset         = BitConverter.ToUInt32(contents, offset.Shift(4));
            _flags          = (ManifestResourceAttributes)BitConverter.ToUInt32(contents, offset.Shift(4));
            _name           = new StringIndex(contents, sizeOfStringIndex, offset);
            _implementation = resolver.Resolve(
                CodedIndexes.Implementation,
                FieldReader.ToUInt32(contents, offset.Shift(sizeOfImplementationIndex), sizeOfImplementationIndex)
                );
        }
Exemplo n.º 13
0
        /// <summary>
        /// Initialises a new instance of the ConstantMetadataTableRow
        /// </summary>
        /// <param name="contents">The contents fo the file</param>
        /// <param name="offset">The offset for the current row</param>
        public ConstantMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  hasConstantIndexSize = resolver.GetSizeOfIndex(CodedIndexes.HasConstant);
            byte sizeOfBlobIndex      = indexDetails.GetSizeOfBlobIndex();

            _type = (Signatures.ElementTypes)contents[offset.Shift(1)];
            offset.Shift(1);
            _parentIndex = resolver.Resolve(
                CodedIndexes.HasConstant,
                FieldReader.ToUInt32(contents, offset.Shift(hasConstantIndexSize), hasConstantIndexSize)
                );
            _valueIndex = new BlobIndex(sizeOfBlobIndex, contents, Signatures.Signatures.MethodDef, offset);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Initialises a new instance of the ImplMapMetadataTableRow class
        /// </summary>
        /// <param name="content">The content of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public ImplMapMetadataTableRow(byte[] content, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfMemberForwardedIndex = resolver.GetSizeOfIndex(CodedIndexes.MemberForwarded);
            byte sizeOfStringIndex          = indexDetails.GetSizeOfStringIndex();
            byte sizeOfModuleRefIndex       = indexDetails.GetSizeOfIndex(MetadataTables.ModuleRef);

            _mappingFlags  = (PInvokeAttributes)FieldReader.ToUInt16(content, offset.Shift(2));
            _memberForward = resolver.Resolve(CodedIndexes.MemberForwarded,
                                              FieldReader.ToUInt32(content, offset.Shift(sizeOfMemberForwardedIndex), sizeOfMemberForwardedIndex)
                                              );
            _importName  = new StringIndex(content, sizeOfStringIndex, offset);
            _importScope = new Index(content, offset, sizeOfModuleRefIndex);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Initialises a new instance of the ExportedTypeMetadataTableRow class
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public ExportedTypeMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            byte sizeOfStringIndex         = indexDetails.GetSizeOfStringIndex();
            int  sizeOfImplementationIndex = resolver.GetSizeOfIndex(CodedIndexes.Implementation);

            _flags               = (TypeAttributes)FieldReader.ToUInt32(contents, offset.Shift(4));
            _typeDefId           = FieldReader.ToUInt32(contents, offset.Shift(4));
            _typeNameIndex       = new StringIndex(contents, sizeOfStringIndex, offset);
            _typeNamespaceIndex  = new StringIndex(contents, sizeOfStringIndex, offset);
            _implementationIndex = resolver.Resolve(
                CodedIndexes.Implementation,
                FieldReader.ToUInt32(contents, offset.Shift(sizeOfImplementationIndex), sizeOfImplementationIndex)
                );
        }
Exemplo n.º 16
0
        /// <summary>
        /// Initialises an instance of the TypeDefMetadataTableRow
        /// </summary>
        /// <param name="contents">The contents of the file</param>
        /// <param name="offset">The offset of the current row</param>
        public TypeDefMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
        {
            this.FileOffset = offset;

            int  sizeOfCodedIndex  = resolver.GetSizeOfIndex(CodedIndexes.TypeDefOrRef);
            byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
            byte sizeOfFieldIndex  = indexDetails.GetSizeOfIndex(MetadataTables.Field);
            byte sizeOfMethodIndex = indexDetails.GetSizeOfIndex(MetadataTables.MethodDef);

            _flags          = (TypeAttributes)FieldReader.ToUInt32(contents, offset.Shift(4));
            _nameIndex      = new StringIndex(contents, sizeOfStringIndex, offset);
            _namespaceIndex = new StringIndex(contents, sizeOfStringIndex, offset);
            _extends        = resolver.Resolve(CodedIndexes.TypeDefOrRef,
                                               FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
                                               );
            _fieldList  = new Index(contents, offset, sizeOfFieldIndex);
            _methodList = new Index(contents, offset, sizeOfMethodIndex);
        }