BinaryObjectScanner/BinaryObjectScanner.Wrappers/NewExecutable.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using static SabreTools.Serialization.Extensions;

namespace BinaryObjectScanner.Wrappers
{
    public class NewExecutable : WrapperBase<SabreTools.Models.NewExecutable.Executable>
    {
        #region Descriptive Properties

        /// <inheritdoc/>
        public override string DescriptionString => "New Executable (NE)";

        #endregion

        #region Pass-Through Properties

        #region MS-DOS Stub

        #region Standard Fields

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.Magic"/>
#if NET48
        public string Stub_Magic => _model.Stub.Header.Magic;
#else
        public string? Stub_Magic => _model.Stub?.Header?.Magic;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.LastPageBytes"/>
#if NET48
        public ushort Stub_LastPageBytes => _model.Stub.Header.LastPageBytes;
#else
        public ushort? Stub_LastPageBytes => _model.Stub?.Header?.LastPageBytes;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.Pages"/>
#if NET48
        public ushort Stub_Pages => _model.Stub.Header.Pages;
#else
        public ushort? Stub_Pages => _model.Stub?.Header?.Pages;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.RelocationItems"/>
#if NET48
        public ushort Stub_RelocationItems => _model.Stub.Header.RelocationItems;
#else
        public ushort? Stub_RelocationItems => _model.Stub?.Header?.RelocationItems;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.HeaderParagraphSize"/>
#if NET48
        public ushort Stub_HeaderParagraphSize => _model.Stub.Header.HeaderParagraphSize;
#else
        public ushort? Stub_HeaderParagraphSize => _model.Stub?.Header?.HeaderParagraphSize;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.MinimumExtraParagraphs"/>
#if NET48
        public ushort Stub_MinimumExtraParagraphs => _model.Stub.Header.MinimumExtraParagraphs;
#else
        public ushort? Stub_MinimumExtraParagraphs => _model.Stub?.Header?.MinimumExtraParagraphs;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.MaximumExtraParagraphs"/>
#if NET48
        public ushort Stub_MaximumExtraParagraphs => _model.Stub.Header.MaximumExtraParagraphs;
#else
        public ushort? Stub_MaximumExtraParagraphs => _model.Stub?.Header?.MaximumExtraParagraphs;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.InitialSSValue"/>
#if NET48
        public ushort Stub_InitialSSValue => _model.Stub.Header.InitialSSValue;
#else
        public ushort? Stub_InitialSSValue => _model.Stub?.Header?.InitialSSValue;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.InitialSPValue"/>
#if NET48
        public ushort Stub_InitialSPValue => _model.Stub.Header.InitialSPValue;
#else
        public ushort? Stub_InitialSPValue => _model.Stub?.Header?.InitialSPValue;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.Checksum"/>
#if NET48
        public ushort Stub_Checksum => _model.Stub.Header.Checksum;
#else
        public ushort? Stub_Checksum => _model.Stub?.Header?.Checksum;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.InitialIPValue"/>
#if NET48
        public ushort Stub_InitialIPValue => _model.Stub.Header.InitialIPValue;
#else
        public ushort? Stub_InitialIPValue => _model.Stub?.Header?.InitialIPValue;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.InitialCSValue"/>
#if NET48
        public ushort Stub_InitialCSValue => _model.Stub.Header.InitialCSValue;
#else
        public ushort? Stub_InitialCSValue => _model.Stub?.Header?.InitialCSValue;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.RelocationTableAddr"/>
#if NET48
        public ushort Stub_RelocationTableAddr => _model.Stub.Header.RelocationTableAddr;
#else
        public ushort? Stub_RelocationTableAddr => _model.Stub?.Header?.RelocationTableAddr;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.OverlayNumber"/>
#if NET48
        public ushort Stub_OverlayNumber => _model.Stub.Header.OverlayNumber;
#else
        public ushort? Stub_OverlayNumber => _model.Stub?.Header?.OverlayNumber;
#endif

        #endregion

        #region PE Extensions

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.Reserved1"/>
#if NET48
        public ushort[] Stub_Reserved1 => _model.Stub.Header.Reserved1;
#else
        public ushort[]? Stub_Reserved1 => _model.Stub?.Header?.Reserved1;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.OEMIdentifier"/>
#if NET48
        public ushort Stub_OEMIdentifier => _model.Stub.Header.OEMIdentifier;
#else
        public ushort? Stub_OEMIdentifier => _model.Stub?.Header?.OEMIdentifier;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.OEMInformation"/>
#if NET48
        public ushort Stub_OEMInformation => _model.Stub.Header.OEMInformation;
#else
        public ushort? Stub_OEMInformation => _model.Stub?.Header?.OEMInformation;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.Reserved2"/>
#if NET48
        public ushort[] Stub_Reserved2 => _model.Stub.Header.Reserved2;
#else
        public ushort[]? Stub_Reserved2 => _model.Stub?.Header?.Reserved2;
#endif

        /// <inheritdoc cref="Models.MSDOS.ExecutableHeader.NewExeHeaderAddr"/>
#if NET48
        public uint Stub_NewExeHeaderAddr => _model.Stub.Header.NewExeHeaderAddr;
#else
        public uint? Stub_NewExeHeaderAddr => _model.Stub?.Header?.NewExeHeaderAddr;
#endif

        #endregion

        #endregion

        #region Header

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.Magic"/>
#if NET48
        public string Magic => _model.Header.Magic;
#else
        public string? Magic => _model.Header?.Magic;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.LinkerVersion"/>
#if NET48
        public byte LinkerVersion => _model.Header.LinkerVersion;
#else
        public byte? LinkerVersion => _model.Header?.LinkerVersion;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.LinkerRevision"/>
#if NET48
        public byte LinkerRevision => _model.Header.LinkerRevision;
#else
        public byte? LinkerRevision => _model.Header?.LinkerRevision;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.EntryTableOffset"/>
#if NET48
        public ushort EntryTableOffset => _model.Header.EntryTableOffset;
#else
        public ushort? EntryTableOffset => _model.Header?.EntryTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.EntryTableSize"/>
#if NET48
        public ushort EntryTableSize => _model.Header.EntryTableSize;
#else
        public ushort? EntryTableSize => _model.Header?.EntryTableSize;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.CrcChecksum"/>
#if NET48
        public uint CrcChecksum => _model.Header.CrcChecksum;
#else
        public uint? CrcChecksum => _model.Header?.CrcChecksum;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.FlagWord"/>
#if NET48
        public SabreTools.Models.NewExecutable.HeaderFlag FlagWord => _model.Header.FlagWord;
#else
        public SabreTools.Models.NewExecutable.HeaderFlag? FlagWord => _model.Header?.FlagWord;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.AutomaticDataSegmentNumber"/>
#if NET48
        public ushort AutomaticDataSegmentNumber => _model.Header.AutomaticDataSegmentNumber;
#else
        public ushort? AutomaticDataSegmentNumber => _model.Header?.AutomaticDataSegmentNumber;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.InitialHeapAlloc"/>
#if NET48
        public ushort InitialHeapAlloc => _model.Header.InitialHeapAlloc;
#else
        public ushort? InitialHeapAlloc => _model.Header?.InitialHeapAlloc;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.InitialStackAlloc"/>
#if NET48
        public ushort InitialStackAlloc => _model.Header.InitialStackAlloc;
#else
        public ushort? InitialStackAlloc => _model.Header?.InitialStackAlloc;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.InitialCSIPSetting"/>
#if NET48
        public uint InitialCSIPSetting => _model.Header.InitialCSIPSetting;
#else
        public uint? InitialCSIPSetting => _model.Header?.InitialCSIPSetting;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.InitialSSSPSetting"/>
#if NET48
        public uint InitialSSSPSetting => _model.Header.InitialSSSPSetting;
#else
        public uint? InitialSSSPSetting => _model.Header?.InitialSSSPSetting;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.FileSegmentCount"/>
#if NET48
        public ushort FileSegmentCount => _model.Header.FileSegmentCount;
#else
        public ushort? FileSegmentCount => _model.Header?.FileSegmentCount;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ModuleReferenceTableSize"/>
#if NET48
        public ushort ModuleReferenceTableSize => _model.Header.ModuleReferenceTableSize;
#else
        public ushort? ModuleReferenceTableSize => _model.Header?.ModuleReferenceTableSize;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.NonResidentNameTableSize"/>
#if NET48
        public ushort NonResidentNameTableSize => _model.Header.NonResidentNameTableSize;
#else
        public ushort? NonResidentNameTableSize => _model.Header?.NonResidentNameTableSize;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.SegmentTableOffset"/>
#if NET48
        public ushort SegmentTableOffset => _model.Header.SegmentTableOffset;
#else
        public ushort? SegmentTableOffset => _model.Header?.SegmentTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ResourceTableOffset"/>
#if NET48
        public ushort ResourceTableOffset => _model.Header.ResourceTableOffset;
#else
        public ushort? ResourceTableOffset => _model.Header?.ResourceTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ResidentNameTableOffset"/>
#if NET48
        public ushort ResidentNameTableOffset => _model.Header.ResidentNameTableOffset;
#else
        public ushort? ResidentNameTableOffset => _model.Header?.ResidentNameTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ModuleReferenceTableOffset"/>
#if NET48
        public ushort ModuleReferenceTableOffset => _model.Header.ModuleReferenceTableOffset;
#else
        public ushort? ModuleReferenceTableOffset => _model.Header?.ModuleReferenceTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ImportedNamesTableOffset"/>
#if NET48
        public ushort ImportedNamesTableOffset => _model.Header.ImportedNamesTableOffset;
#else
        public ushort? ImportedNamesTableOffset => _model.Header?.ImportedNamesTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.NonResidentNamesTableOffset"/>
#if NET48
        public uint NonResidentNamesTableOffset => _model.Header.NonResidentNamesTableOffset;
#else
        public uint? NonResidentNamesTableOffset => _model.Header?.NonResidentNamesTableOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.MovableEntriesCount"/>
#if NET48
        public ushort MovableEntriesCount => _model.Header.MovableEntriesCount;
#else
        public ushort? MovableEntriesCount => _model.Header?.MovableEntriesCount;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.SegmentAlignmentShiftCount"/>
#if NET48
        public ushort SegmentAlignmentShiftCount => _model.Header.SegmentAlignmentShiftCount;
#else
        public ushort? SegmentAlignmentShiftCount => _model.Header?.SegmentAlignmentShiftCount;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ResourceEntriesCount"/>
#if NET48
        public ushort ResourceEntriesCount => _model.Header.ResourceEntriesCount;
#else
        public ushort? ResourceEntriesCount => _model.Header?.ResourceEntriesCount;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.TargetOperatingSystem"/>
#if NET48
        public SabreTools.Models.NewExecutable.OperatingSystem TargetOperatingSystem => _model.Header.TargetOperatingSystem;
#else
        public SabreTools.Models.NewExecutable.OperatingSystem? TargetOperatingSystem => _model.Header?.TargetOperatingSystem;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.AdditionalFlags"/>
#if NET48
        public SabreTools.Models.NewExecutable.OS2Flag AdditionalFlags => _model.Header.AdditionalFlags;
#else
        public SabreTools.Models.NewExecutable.OS2Flag? AdditionalFlags => _model.Header?.AdditionalFlags;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.ReturnThunkOffset"/>
#if NET48
        public ushort ReturnThunkOffset => _model.Header.ReturnThunkOffset;
#else
        public ushort? ReturnThunkOffset => _model.Header?.ReturnThunkOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.SegmentReferenceThunkOffset"/>
#if NET48
        public ushort SegmentReferenceThunkOffset => _model.Header.SegmentReferenceThunkOffset;
#else
        public ushort? SegmentReferenceThunkOffset => _model.Header?.SegmentReferenceThunkOffset;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.MinCodeSwapAreaSize"/>
#if NET48
        public ushort MinCodeSwapAreaSize => _model.Header.MinCodeSwapAreaSize;
#else
        public ushort? MinCodeSwapAreaSize => _model.Header?.MinCodeSwapAreaSize;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.WindowsSDKRevision"/>
#if NET48
        public byte WindowsSDKRevision => _model.Header.WindowsSDKRevision;
#else
        public byte? WindowsSDKRevision => _model.Header?.WindowsSDKRevision;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ExecutableHeader.WindowsSDKVersion"/>
#if NET48
        public byte WindowsSDKVersion => _model.Header.WindowsSDKVersion;
#else
        public byte? WindowsSDKVersion => _model.Header?.WindowsSDKVersion;
#endif

        #endregion

        #region Tables

        /// <inheritdoc cref="Models.NewExecutable.SegmentTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.SegmentTableEntry[] SegmentTable => _model.SegmentTable;
#else
        public SabreTools.Models.NewExecutable.SegmentTableEntry?[]? SegmentTable => _model.SegmentTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ResourceTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.ResourceTable ResourceTable => _model.ResourceTable;
#else
        public SabreTools.Models.NewExecutable.ResourceTable? ResourceTable => _model.ResourceTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ResidentNameTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.ResidentNameTableEntry[] ResidentNameTable => _model.ResidentNameTable;
#else
        public SabreTools.Models.NewExecutable.ResidentNameTableEntry?[]? ResidentNameTable => _model.ResidentNameTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ModuleReferenceTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.ModuleReferenceTableEntry[] ModuleReferenceTable => _model.ModuleReferenceTable;
#else
        public SabreTools.Models.NewExecutable.ModuleReferenceTableEntry?[]? ModuleReferenceTable => _model.ModuleReferenceTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.ImportedNameTable"/>
#if NET48
        public Dictionary<ushort, SabreTools.Models.NewExecutable.ImportedNameTableEntry> ImportedNameTable => _model.ImportedNameTable;
#else
        public Dictionary<ushort, SabreTools.Models.NewExecutable.ImportedNameTableEntry?>? ImportedNameTable => _model.ImportedNameTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.EntryTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.EntryTableBundle[] EntryTable => _model.EntryTable;
#else
        public SabreTools.Models.NewExecutable.EntryTableBundle?[]? EntryTable => _model.EntryTable;
#endif

        /// <inheritdoc cref="Models.NewExecutable.NonResidentNameTable"/>
#if NET48
        public SabreTools.Models.NewExecutable.NonResidentNameTableEntry[] NonResidentNameTable => _model.NonResidentNameTable;
#else
        public SabreTools.Models.NewExecutable.NonResidentNameTableEntry?[]? NonResidentNameTable => _model.NonResidentNameTable;
#endif

        #endregion

        #endregion

        #region Extension Properties

        // TODO: Determine what extension properties are needed

        #endregion

        #region Constructors

        /// <inheritdoc/>
#if NET48
        public NewExecutable(SabreTools.Models.NewExecutable.Executable model, byte[] data, int offset)
#else
        public NewExecutable(SabreTools.Models.NewExecutable.Executable? model, byte[]? data, int offset)
#endif
            : base(model, data, offset)
        {
            // All logic is handled by the base class
        }

        /// <inheritdoc/>
#if NET48
        public NewExecutable(SabreTools.Models.NewExecutable.Executable model, Stream data)
#else
        public NewExecutable(SabreTools.Models.NewExecutable.Executable? model, Stream? data)
#endif
            : base(model, data)
        {
            // All logic is handled by the base class
        }

        /// <summary>
        /// Create an NE executable from a byte array and offset
        /// </summary>
        /// <param name="data">Byte array representing the executable</param>
        /// <param name="offset">Offset within the array to parse</param>
        /// <returns>An NE executable wrapper on success, null on failure</returns>
#if NET48
        public static NewExecutable Create(byte[] data, int offset)
#else
        public static NewExecutable? Create(byte[]? data, int offset)
#endif
        {
            // If the data is invalid
            if (data == null)
                return null;

            // If the offset is out of bounds
            if (offset < 0 || offset >= data.Length)
                return null;

            // Create a memory stream and use that
            MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
            return Create(dataStream);
        }

        /// <summary>
        /// Create an NE executable from a Stream
        /// </summary>
        /// <param name="data">Stream representing the executable</param>
        /// <returns>An NE executable wrapper on success, null on failure</returns>
#if NET48
        public static NewExecutable Create(Stream data)
#else
        public static NewExecutable? Create(Stream? data)
#endif
        {
            // If the data is invalid
            if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
                return null;

            var executable = new SabreTools.Serialization.Streams.NewExecutable().Deserialize(data);
            if (executable == null)
                return null;

            try
            {
                return new NewExecutable(executable, data);
            }
            catch
            {
                return null;
            }
        }

        #endregion

        #region Printing

        /// <inheritdoc/>
        public override StringBuilder PrettyPrint()
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendLine("New Executable Information:");
            builder.AppendLine("-------------------------");
            builder.AppendLine();

            // Stub
            PrintStubHeader(builder);
            PrintStubExtendedHeader(builder);

            // Header
            PrintHeader(builder);

            // Tables
            PrintSegmentTable(builder);
            PrintResourceTable(builder);
            PrintResidentNameTable(builder);
            PrintModuleReferenceTable(builder);
            PrintImportedNameTable(builder);
            PrintEntryTable(builder);
            PrintNonresidentNameTable(builder);

            return builder;
        }

        /// <summary>
        /// Print stub header information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintStubHeader(StringBuilder builder)
        {
            builder.AppendLine("  MS-DOS Stub Header Information:");
            builder.AppendLine("  -------------------------");
            builder.AppendLine($"  Magic number: {Stub_Magic}");
            builder.AppendLine($"  Last page bytes: {Stub_LastPageBytes} (0x{Stub_LastPageBytes:X})");
            builder.AppendLine($"  Pages: {Stub_Pages} (0x{Stub_Pages:X})");
            builder.AppendLine($"  Relocation items: {Stub_RelocationItems} (0x{Stub_RelocationItems:X})");
            builder.AppendLine($"  Header paragraph size: {Stub_HeaderParagraphSize} (0x{Stub_HeaderParagraphSize:X})");
            builder.AppendLine($"  Minimum extra paragraphs: {Stub_MinimumExtraParagraphs} (0x{Stub_MinimumExtraParagraphs:X})");
            builder.AppendLine($"  Maximum extra paragraphs: {Stub_MaximumExtraParagraphs} (0x{Stub_MaximumExtraParagraphs:X})");
            builder.AppendLine($"  Initial SS value: {Stub_InitialSSValue} (0x{Stub_InitialSSValue:X})");
            builder.AppendLine($"  Initial SP value: {Stub_InitialSPValue} (0x{Stub_InitialSPValue:X})");
            builder.AppendLine($"  Checksum: {Stub_Checksum} (0x{Stub_Checksum:X})");
            builder.AppendLine($"  Initial IP value: {Stub_InitialIPValue} (0x{Stub_InitialIPValue:X})");
            builder.AppendLine($"  Initial CS value: {Stub_InitialCSValue} (0x{Stub_InitialCSValue:X})");
            builder.AppendLine($"  Relocation table address: {Stub_RelocationTableAddr} (0x{Stub_RelocationTableAddr:X})");
            builder.AppendLine($"  Overlay number: {Stub_OverlayNumber} (0x{Stub_OverlayNumber:X})");
            builder.AppendLine();
        }

        /// <summary>
        /// Print stub extended header information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintStubExtendedHeader(StringBuilder builder)
        {
            builder.AppendLine("  MS-DOS Stub Extended Header Information:");
            builder.AppendLine("  -------------------------");
            builder.AppendLine($"  Reserved words: {(Stub_Reserved1 == null ? "[NULL]" : string.Join(", ", Stub_Reserved1))}");
            builder.AppendLine($"  OEM identifier: {Stub_OEMIdentifier} (0x{Stub_OEMIdentifier:X})");
            builder.AppendLine($"  OEM information: {Stub_OEMInformation} (0x{Stub_OEMInformation:X})");
            builder.AppendLine($"  Reserved words: {(Stub_Reserved2 == null ? "[NULL]" : string.Join(", ", Stub_Reserved2))}");
            builder.AppendLine($"  New EXE header address: {Stub_NewExeHeaderAddr} (0x{Stub_NewExeHeaderAddr:X})");
            builder.AppendLine();
        }

        /// <summary>
        /// Print header information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintHeader(StringBuilder builder)
        {
            builder.AppendLine("  Header Information:");
            builder.AppendLine("  -------------------------");
            builder.AppendLine($"  Magic number: {Magic}");
            builder.AppendLine($"  Linker version: {LinkerVersion} (0x{LinkerVersion:X})");
            builder.AppendLine($"  Linker revision: {LinkerRevision} (0x{LinkerRevision:X})");
            builder.AppendLine($"  Entry table offset: {EntryTableOffset} (0x{EntryTableOffset:X})");
            builder.AppendLine($"  Entry table size: {EntryTableSize} (0x{EntryTableSize:X})");
            builder.AppendLine($"  CRC checksum: {CrcChecksum} (0x{CrcChecksum:X})");
            builder.AppendLine($"  Flag word: {FlagWord} (0x{FlagWord:X})");
            builder.AppendLine($"  Automatic data segment number: {AutomaticDataSegmentNumber} (0x{AutomaticDataSegmentNumber:X})");
            builder.AppendLine($"  Initial heap allocation: {InitialHeapAlloc} (0x{InitialHeapAlloc:X})");
            builder.AppendLine($"  Initial stack allocation: {InitialStackAlloc} (0x{InitialStackAlloc:X})");
            builder.AppendLine($"  Initial CS:IP setting: {InitialCSIPSetting} (0x{InitialCSIPSetting:X})");
            builder.AppendLine($"  Initial SS:SP setting: {InitialSSSPSetting} (0x{InitialSSSPSetting:X})");
            builder.AppendLine($"  File segment count: {FileSegmentCount} (0x{FileSegmentCount:X})");
            builder.AppendLine($"  Module reference table size: {ModuleReferenceTableSize} (0x{ModuleReferenceTableSize:X})");
            builder.AppendLine($"  Non-resident name table size: {NonResidentNameTableSize} (0x{NonResidentNameTableSize:X})");
            builder.AppendLine($"  Segment table offset: {SegmentTableOffset} (0x{SegmentTableOffset:X})");
            builder.AppendLine($"  Resource table offset: {ResourceTableOffset} (0x{ResourceTableOffset:X})");
            builder.AppendLine($"  Resident name table offset: {ResidentNameTableOffset} (0x{ResidentNameTableOffset:X})");
            builder.AppendLine($"  Module reference table offset: {ModuleReferenceTableOffset} (0x{ModuleReferenceTableOffset:X})");
            builder.AppendLine($"  Imported names table offset: {ImportedNamesTableOffset} (0x{ImportedNamesTableOffset:X})");
            builder.AppendLine($"  Non-resident name table offset: {NonResidentNamesTableOffset} (0x{NonResidentNamesTableOffset:X})");
            builder.AppendLine($"  Moveable entries count: {MovableEntriesCount} (0x{MovableEntriesCount:X})");
            builder.AppendLine($"  Segment alignment shift count: {SegmentAlignmentShiftCount} (0x{SegmentAlignmentShiftCount:X})");
            builder.AppendLine($"  Resource entries count: {ResourceEntriesCount} (0x{ResourceEntriesCount:X})");
            builder.AppendLine($"  Target operating system: {TargetOperatingSystem} (0x{TargetOperatingSystem:X})");
            builder.AppendLine($"  Additional flags: {AdditionalFlags} (0x{AdditionalFlags:X})");
            builder.AppendLine($"  Return thunk offset: {ReturnThunkOffset} (0x{ReturnThunkOffset:X})");
            builder.AppendLine($"  Segment reference thunk offset: {SegmentReferenceThunkOffset} (0x{SegmentReferenceThunkOffset:X})");
            builder.AppendLine($"  Minimum code swap area size: {MinCodeSwapAreaSize} (0x{MinCodeSwapAreaSize:X})");
            builder.AppendLine($"  Windows SDK revision: {WindowsSDKRevision} (0x{WindowsSDKRevision:X})");
            builder.AppendLine($"  Windows SDK version: {WindowsSDKVersion} (0x{WindowsSDKVersion:X})");
            builder.AppendLine();
        }

        /// <summary>
        /// Print segment table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintSegmentTable(StringBuilder builder)
        {
            builder.AppendLine("  Segment Table Information:");
            builder.AppendLine("  -------------------------");
            if (FileSegmentCount == 0 || SegmentTable == null || SegmentTable.Length == 0)
            {
                builder.AppendLine("  No segment table items");
            }
            else
            {
                for (int i = 0; i < SegmentTable.Length; i++)
                {
                    var entry = SegmentTable[i];
                    builder.AppendLine($"  Segment Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Offset: {entry.Offset} (0x{entry.Offset:X})");
                    builder.AppendLine($"    Length: {entry.Length} (0x{entry.Length:X})");
                    builder.AppendLine($"    Flag word: {entry.FlagWord} (0x{entry.FlagWord:X})");
                    builder.AppendLine($"    Minimum allocation size: {entry.MinimumAllocationSize} (0x{entry.MinimumAllocationSize:X})");
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print resource table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintResourceTable(StringBuilder builder)
        {
            builder.AppendLine("  Resource Table Information:");
            builder.AppendLine("  -------------------------");
            if (ResourceTable == null)
            {
                builder.AppendLine("  No resource table");
                return;
            }

            builder.AppendLine($"  Alignment shift count: {ResourceTable.AlignmentShiftCount} (0x{ResourceTable.AlignmentShiftCount:X})");
            if (ResourceEntriesCount == 0 || ResourceTable.ResourceTypes == null || ResourceTable.ResourceTypes.Length == 0)
            {
                builder.AppendLine("  No resource table items");
            }
            else
            {
                for (int i = 0; i < ResourceTable.ResourceTypes.Length; i++)
                {
                    // TODO: If not integer type, print out name
                    var entry = ResourceTable.ResourceTypes[i];
                    builder.AppendLine($"  Resource Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Type ID: {entry.TypeID} (0x{entry.TypeID:X}) (Is Integer Type: {entry.IsIntegerType()})");
                    builder.AppendLine($"    Resource count: {entry.ResourceCount} (0x{entry.ResourceCount:X})");
                    builder.AppendLine($"    Reserved: {entry.Reserved} (0x{entry.Reserved:X})");
                    builder.AppendLine($"    Resources = ");
                    if (entry.ResourceCount == 0 || entry.Resources == null || entry.Resources.Length == 0)
                    {
                        builder.AppendLine("      No resource items");
                    }
                    else
                    {
                        for (int j = 0; j < entry.Resources.Length; j++)
                        {
                            // TODO: If not integer type, print out name
                            var resource = entry.Resources[j];
                            builder.AppendLine($"      Resource Entry {i}");
                            if (resource == null)
                            {
                                builder.AppendLine("      [NULL]");
                                continue;
                            }

                            builder.AppendLine($"        Offset: {resource.Offset} (0x{resource.Offset:X})");
                            builder.AppendLine($"        Length: {resource.Length} (0x{resource.Length:X})");
                            builder.AppendLine($"        Flag word: {resource.FlagWord} (0x{resource.FlagWord:X})");
                            builder.AppendLine($"        Resource ID: {resource.ResourceID} (0x{resource.ResourceID:X}) (Is Integer Type: {resource.IsIntegerType()})");
                            builder.AppendLine($"        Reserved: {resource.Reserved} (0x{resource.Reserved:X})");
                        }
                    }
                }
            }

            if (ResourceTable.TypeAndNameStrings == null || ResourceTable.TypeAndNameStrings.Count == 0)
            {
                builder.AppendLine("  No resource table type/name strings");
            }
            else
            {
                foreach (var typeAndNameString in ResourceTable.TypeAndNameStrings)
                {
                    builder.AppendLine($"  Resource Type/Name Offset {typeAndNameString.Key}");
#if NET6_0_OR_GREATER
                    if (typeAndNameString.Value == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }
#endif
                    builder.AppendLine($"    Length: {typeAndNameString.Value.Length} (0x{typeAndNameString.Value.Length:X})");
                    builder.AppendLine($"    Text: {(typeAndNameString.Value.Text != null ? Encoding.ASCII.GetString(typeAndNameString.Value.Text).TrimEnd('\0') : "[EMPTY]")}");
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print resident-name table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintResidentNameTable(StringBuilder builder)
        {
            builder.AppendLine("  Resident-Name Table Information:");
            builder.AppendLine("  -------------------------");
            if (ResidentNameTableOffset == 0 || ResidentNameTable == null || ResidentNameTable.Length == 0)
            {
                builder.AppendLine("  No resident-name table items");
            }
            else
            {
                for (int i = 0; i < ResidentNameTable.Length; i++)
                {
                    var entry = ResidentNameTable[i];
                    builder.AppendLine($"  Resident-Name Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Length: {entry.Length} (0x{entry.Length:X})");
                    builder.AppendLine($"    Name string: {(entry.NameString != null ? Encoding.ASCII.GetString(entry.NameString).TrimEnd('\0') : "[EMPTY]")}");
                    builder.AppendLine($"    Ordinal number: {entry.OrdinalNumber} (0x{entry.OrdinalNumber:X})");
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print module-reference table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintModuleReferenceTable(StringBuilder builder)
        {
            builder.AppendLine("  Module-Reference Table Information:");
            builder.AppendLine("  -------------------------");
            if (ModuleReferenceTableSize == 0 || ModuleReferenceTable == null || ModuleReferenceTable.Length == 0)
            {
                builder.AppendLine("  No module-reference table items");
            }
            else
            {
                for (int i = 0; i < ModuleReferenceTable.Length; i++)
                {
                    // TODO: Read the imported names table and print value here
                    var entry = ModuleReferenceTable[i];
                    builder.AppendLine($"  Module-Reference Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Offset: {entry.Offset} (adjusted to be {entry.Offset + Stub_NewExeHeaderAddr + ImportedNamesTableOffset})");
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print imported-name table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintImportedNameTable(StringBuilder builder)
        {
            builder.AppendLine("  Imported-Name Table Information:");
            builder.AppendLine("  -------------------------");
            if (ImportedNamesTableOffset == 0 || ImportedNameTable == null || ImportedNameTable.Count == 0)
            {
                builder.AppendLine("  No imported-name table items");
            }
            else
            {
                foreach (var entry in ImportedNameTable)
                {
                    builder.AppendLine($"  Imported-Name Table at Offset {entry.Key}");
#if NET6_0_OR_GREATER
                    if (entry.Value == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }
#endif
                    builder.AppendLine($"    Length: {entry.Value.Length} (0x{entry.Value.Length:X})");
                    builder.AppendLine($"    Name string: {(entry.Value.NameString != null ? Encoding.ASCII.GetString(entry.Value.NameString) : "[EMPTY]")}");
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print entry table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintEntryTable(StringBuilder builder)
        {
            builder.AppendLine("  Entry Table Information:");
            builder.AppendLine("  -------------------------");
            if (EntryTableSize == 0 || EntryTable == null || EntryTable.Length == 0)
            {
                builder.AppendLine("  No entry table items");
            }
            else
            {
                for (int i = 0; i < EntryTable.Length; i++)
                {
                    var entry = EntryTable[i];
                    builder.AppendLine($"  Entry Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Entry count: {entry.EntryCount} (0x{entry.EntryCount:X})");
                    builder.AppendLine($"    Segment indicator: {entry.SegmentIndicator} (0x{entry.SegmentIndicator:X}) ({entry.GetEntryType()})");
                    switch (entry.GetEntryType())
                    {
                        case SabreTools.Models.NewExecutable.SegmentEntryType.FixedSegment:
                            builder.AppendLine($"    Flag word: {entry.FixedFlagWord} (0x{entry.FixedFlagWord:X})");
                            builder.AppendLine($"    Offset: {entry.FixedOffset} (0x{entry.FixedOffset:X})");
                            break;
                        case SabreTools.Models.NewExecutable.SegmentEntryType.MoveableSegment:
                            builder.AppendLine($"    Flag word: {entry.MoveableFlagWord} (0x{entry.MoveableFlagWord:X})");
                            builder.AppendLine($"    Reserved: {entry.MoveableReserved} (0x{entry.MoveableReserved:X})");
                            builder.AppendLine($"    Segment number: {entry.MoveableSegmentNumber} (0x{entry.MoveableSegmentNumber:X})");
                            builder.AppendLine($"    Offset: {entry.MoveableOffset} (0x{entry.MoveableOffset:X})");
                            break;
                    }
                }
            }
            builder.AppendLine();
        }

        /// <summary>
        /// Print nonresident-name table information
        /// </summary>
        /// <param name="builder">StringBuilder to append information to</param>
        private void PrintNonresidentNameTable(StringBuilder builder)
        {
            builder.AppendLine("  Nonresident-Name Table Information:");
            builder.AppendLine("  -------------------------");
            if (NonResidentNameTableSize == 0 || NonResidentNameTable == null || NonResidentNameTable.Length == 0)
            {
                builder.AppendLine("  No nonresident-name table items");
            }
            else
            {
                for (int i = 0; i < NonResidentNameTable.Length; i++)
                {
                    var entry = NonResidentNameTable[i];
                    builder.AppendLine($"  Nonresident-Name Table Entry {i}");
                    if (entry == null)
                    {
                        builder.AppendLine("    [NULL]");
                        continue;
                    }

                    builder.AppendLine($"    Length: {entry.Length} (0x{entry.Length:X})");
                    builder.AppendLine($"    Name string: {(entry.NameString != null ? Encoding.ASCII.GetString(entry.NameString) : "[EMPTY]")}");
                    builder.AppendLine($"    Ordinal number: {entry.OrdinalNumber} (0x{entry.OrdinalNumber:X})");
                }
            }
            builder.AppendLine();
        }

#if NET6_0_OR_GREATER

        /// <inheritdoc/>
        public override string ExportJSON() =>  System.Text.Json.JsonSerializer.Serialize(_model, _jsonSerializerOptions);

#endif

        #endregion

        #region REMOVE -- DO NOT USE

        /// <summary>
        /// Read an arbitrary range from the source
        /// </summary>
        /// <param name="rangeStart">The start of where to read data from, -1 means start of source</param>
        /// <param name="length">How many bytes to read, -1 means read until end</param>
        /// <returns>Byte array representing the range, null on error</returns>
        [Obsolete]
#if NET48
        public byte[] ReadArbitraryRange(int rangeStart = -1, int length = -1)
#else
        public byte[]? ReadArbitraryRange(int rangeStart = -1, int length = -1)
#endif
        {
            // If we have an unset range start, read from the start of the source
            if (rangeStart == -1)
                rangeStart = 0;

            // If we have an unset length, read the whole source
            if (length == -1)
            {
                switch (_dataSource)
                {
                    case DataSource.ByteArray:
#if NET48
                        length = _byteArrayData.Length - _byteArrayOffset;
#else
                        length = _byteArrayData!.Length - _byteArrayOffset;
#endif
                        break;

                    case DataSource.Stream:
#if NET48
                        length = (int)_streamData.Length;
#else
                        length = (int)_streamData!.Length;
#endif
                        break;
                }
            }

            return ReadFromDataSource(rangeStart, length);
        }

        #endregion
    }
}