コード例 #1
0
        /// <inheritdoc />
        public void UpdateOffsets(ulong newOffset, uint newRva)
        {
            Offset        = newOffset;
            Rva           = newRva;
            _physicalSize = 0;
            _virtualSize  = 0;

            foreach (var item in _items)
            {
                uint physicalPadding = (uint)(newOffset.Align(item.Alignment) - newOffset);
                uint virtualPadding  = newRva.Align(item.Alignment) - newRva;

                newOffset += physicalPadding;
                newRva    += virtualPadding;

                item.Segment.UpdateOffsets(newOffset, newRva);

                uint physicalSize = item.Segment.GetPhysicalSize();
                uint virtualSize  = item.Segment.GetVirtualSize();

                newOffset     += physicalSize;
                newRva        += virtualSize;
                _physicalSize += physicalPadding + physicalSize;
                _virtualSize  += virtualPadding + virtualSize;
            }
        }
コード例 #2
0
        private static void PackMetadata(Stream target, HyoutaArchiveChunkInfo chunkInfo, byte packedAlignment, EndianUtils.Endianness endian, long fileStartPosition)
        {
            // TODO: actually pack stuff here
            byte  smallPackedAlignment = ToSmallPackedAlignment(packedAlignment);
            ulong length = 8;             // length including the intial 8 byte length field, for data alignment

            target.WriteUInt64(length.Align(1 << smallPackedAlignment) - 8, endian);
            return;
        }
コード例 #3
0
        /// <inheritdoc />
        public override void UpdateOffsets(ulong newOffset, uint newRva)
        {
            base.UpdateOffsets(newOffset, newRva);

            ulong currentOffset = newOffset;

            foreach (var module in _modules)
            {
                foreach (var entry in module.Symbols)
                {
                    if (entry.IsImportByName)
                    {
                        _hintNameOffsets[entry] = (uint)(currentOffset - newOffset);
                        currentOffset          += (uint)(sizeof(ushort) + Encoding.ASCII.GetByteCount(entry.Name) + 1);
                        currentOffset           = currentOffset.Align(2);
                    }
                }
                _moduleNameOffsets[module] = (uint)(currentOffset - newOffset);
                currentOffset += (uint)Encoding.ASCII.GetByteCount(module.Name) + 1;
            }

            _length = (uint)(currentOffset - newOffset);
        }
コード例 #4
0
        /// <summary>
        /// Aligns the writer to a specified boundary.
        /// </summary>
        /// <param name="writer">The writer to align.</param>
        /// <param name="align">The boundary to use.</param>
        public static void Align(this IBinaryStreamWriter writer, uint align)
        {
            ulong currentPosition = writer.Offset;

            writer.WriteZeroes((int)(currentPosition.Align(align) - writer.Offset));
        }