Example #1
0
        private void InitializeTable(IDotNetDirectory netDirectory)
        {
            var tableStream = netDirectory.Metadata.GetStream <TablesStream>();

            for (TableIndex index = 0; index < TableIndex.Max; index++)
            {
                var table = tableStream.GetTable(index);
                _buckets[(int)index] = new TokenBucket(new MetadataToken(index, (uint)table.Count + 1));
            }
        }
Example #2
0
 private void Initialize(IDotNetDirectory netDirectory)
 {
     if (netDirectory is null)
     {
         InitializeDefault();
     }
     else
     {
         InitializeTable(netDirectory);
     }
 }
Example #3
0
        private void InitializeTable(IDotNetDirectory netDirectory, Array tableIndexes)
        {
            var tableStream = netDirectory.Metadata.GetStream <TablesStream>();

            foreach (TableIndex index in tableIndexes)
            {
                var table = tableStream.GetTable(index);
                var rid   = (uint)table.Count + 1;
                _nextTokens[index] = new MetadataToken(index, rid);
            }
        }
Example #4
0
        private void Initialize(IDotNetDirectory netDirectory)
        {
            var tableIndexes = Enum.GetValues(typeof(TableIndex));

            if (netDirectory is null)
            {
                InitailizeDefault(tableIndexes);
            }
            else
            {
                InitializeTable(netDirectory, tableIndexes);
            }
        }
Example #5
0
        /// <summary>
        /// Creates an assembly definition from an assembly metadata row.
        /// </summary>
        /// <param name="dotNetDirectory">The object providing access to the underlying metadata streams.</param>
        /// <param name="token">The token to initialize the assembly for.</param>
        /// <param name="row">The metadata table row to base the assembly definition on.</param>
        /// <param name="manifestModule">The instance containing the manifest module definition.</param>
        /// <param name="readParameters">The parameters to use for reading modules.</param>
        public SerializedAssemblyDefinition(IDotNetDirectory dotNetDirectory, MetadataToken token, AssemblyDefinitionRow row,
                                            SerializedModuleDefinition manifestModule, ModuleReadParameters readParameters)
            : base(token)
        {
            _dotNetDirectory = dotNetDirectory ?? throw new ArgumentNullException(nameof(dotNetDirectory));
            _row             = row;
            _manifestModule  = manifestModule ?? throw new ArgumentNullException(nameof(manifestModule));
            _readParameters  = readParameters ?? throw new ArgumentNullException(nameof(readParameters));
            _parentModule    = manifestModule;

            Attributes    = row.Attributes;
            Version       = new Version(row.MajorVersion, row.MinorVersion, row.BuildNumber, row.RevisionNumber);
            HashAlgorithm = row.HashAlgorithm;
        }
        /// <summary>
        /// Creates a new .NET segment buffer.
        /// </summary>
        /// <param name="dotNetDirectory">The .NET directory to base it on.</param>
        public DotNetSegmentBuffer(IDotNetDirectory dotNetDirectory)
        {
            _segments = new SegmentBuilder
            {
                (DotNetDirectory = dotNetDirectory),
                (FieldRvaTable = new SegmentBuilder()),
                (MethodBodyTable = new MethodBodyTableBuffer())
            };

            AddIfPresent(dotNetDirectory.Metadata);
            AddIfPresent(dotNetDirectory.DotNetResources);
            AddIfPresent(dotNetDirectory.StrongName);
            AddIfPresent(dotNetDirectory.VTableFixups);
            AddIfPresent(dotNetDirectory.ExportAddressTable);
            AddIfPresent(dotNetDirectory.ManagedNativeHeader);
        }
Example #7
0
 /// <summary>
 /// Creates a new instance of teh <see cref="DotNetDirectoryBuildResult"/> class.
 /// </summary>
 /// <param name="directory">The constructed directory.</param>
 /// <param name="mapping">An object defining a mapping between members and their new metadata tokens.</param>
 public DotNetDirectoryBuildResult(IDotNetDirectory directory, ITokenMapping mapping)
 {
     Directory    = directory ?? throw new ArgumentNullException(nameof(directory));
     TokenMapping = mapping ?? throw new ArgumentNullException(nameof(mapping));
 }