public void IdataCharacteristicsArePlausible()
{
var characteristics = SectionHeaders.First(sec => sec.NameString.StartsWith(".idata")).Characteristics;
Assert.That(characteristics.HasFlag(SectionCharacteristics.MemRead), ".idata should be readable");
Assert.That(characteristics.HasFlag(SectionCharacteristics.ContainsInitializedData), ".idata should contain initialized data");
}
internal void Read(PeReader rdr)
{
rdr.SetPosition(0);
if (t == PeFileType.Image)
{
dos = new DOSHeader(this);
dos.Read(rdr);
rdr.SetPosition(dos.PEHeaderOffset);
sign = rdr.ReadBytes(4);
pe = new PEHeader(this);
pe.Read(rdr);
op = new OptionalHeader(this);
op.Read(rdr);
sects = new SectionHeaders(this);
sects.Read(rdr);
certs = new CertificateDirectory(op.DataDirectories[DataDirectoryType.Certificate]);
certs.Load(rdr, op.DataDirectories[DataDirectoryType.Certificate].Address.Value);
}
else if (t == PeFileType.Object)
{
pe = new PEHeader(this);
pe.Read(rdr);
sects = new SectionHeaders(this);
sects.Read(rdr);
}
}
public static void WriteChunk(BBData data, SectionHeaders chunk, BBData inner)
{
var bb = data.Buffer;
bb.Write((uint)chunk);
Write(bb, inner);
}
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms680341(v=vs.85).aspx
private void ParseImageSectionHeader()
{
var header = FromBinaryReader <IMAGE_SECTION_HEADER>(Reader);
SectionHeaders.Add(header);
LogStructure(header);
Reader.BaseStream.Seek(-4, SeekOrigin.Current); // The f**k? Why is this needed?
}
/// <summary>
/// Determines the image section the given relative virtual address (RVA) is located at.
/// </summary>
/// <param name="rva">The relative virtual address to check.</param>
/// <returns>The section the <paramref name="rva"/> is located.</returns>
public ImageSectionHeader GetSectionHeaderByRva(long rva)
{
return
(SectionHeaders.FirstOrDefault(
sectionHeader =>
rva >= sectionHeader.VirtualAddress &&
rva < sectionHeader.VirtualAddress + sectionHeader.VirtualSize));
}
/// <summary>
/// Determines the image section the given absolute file offset is located at.
/// </summary>
/// <param name="fileOffset">The absolute file offset to check.</param>
/// <returns>The section the <paramref name="fileOffset"/> is located.</returns>
public ImageSectionHeader GetSectionHeaderByFileOffset(long fileOffset)
{
return
(SectionHeaders.FirstOrDefault(
sectionHeader =>
fileOffset >= sectionHeader.PointerToRawData &&
fileOffset < sectionHeader.PointerToRawData + sectionHeader.SizeOfRawData));
}
public SectionHeader *GetChunk(SectionHeaders ident)
{
if (Chunks.ContainsKey(ident))
{
return((SectionHeader *)Chunks[ident]);
}
return(null);
}
public ElfFile(MemoryStream stream)
{
//load main file header
ElfHeader = new Elf32Ehdr((Elf32_Ehdr *)stream.Pointer);
//load section headers
var header = (Elf32_Shdr *)(stream.Pointer + ElfHeader.Shoff);
for (int i = 0; i < ElfHeader.Shnum; i++)
{
var x = new Elf32Shdr(&header[i]);
if (x.Type == SectionType.StringTable)
{
_stringTables.Add(x.Offset);
}
SectionHeaders.Add(x);
}
//now we can load names into symbols and process sub data
for (var index = 0; index < SectionHeaders.Count; index++)
{
var sectionHeader = SectionHeaders[index];
sectionHeader.Name = ResolveName(sectionHeader, sectionHeader.NameOffset, stream);
switch (sectionHeader.Type)
{
case SectionType.Relocation:
for (int i = 0; i < sectionHeader.Size / sectionHeader.Entsize; i++)
{
RelocationInformation.Add(new Elf32Rel(
(Elf32_Rel *)(stream.Pointer + sectionHeader.Offset + i * sectionHeader.Entsize))
{
Section = index
});
}
break;
case SectionType.SymbolTable:
for (int i = 0; i < sectionHeader.Size / sectionHeader.Entsize; i++)
{
var x = new Elf32Sym(
(Elf32_Sym *)(stream.Pointer + sectionHeader.Offset + i * sectionHeader.Entsize));
x.Name = ResolveName(sectionHeader, x.NameOffset, stream);
Symbols.Add(x);
}
break;
}
}
}
public IEnumerable <Section> GetSections(SectionHeaders header)
{
if (!HasSubSections)
{
yield break;
}
foreach (var section in SubSections)
{
if (section.Header == (uint)header)
{
yield return(section);
}
}
}
public static string ToChunkName(this SectionHeaders h)
{
sb.Clear();
var u = (uint)h;
var c3 = (char)((u & 0xFF000000) >> 24);
var c2 = (char)((u & 0x00FF0000) >> 16);
var c1 = (char)((u & 0x0000FF00) >> 8);
var c0 = (char)((u & 0x000000FF));
return(sb
.Append(c0).Append(c1).Append(c2).Append(c3)
.ToString());
}
public Section GetSection(SectionHeaders header)
{
if (!HasSubSections)
{
return(null);
}
foreach (var section in SubSections)
{
if (section.Header == (uint)header)
{
return(section);
}
}
return(null);
}
private bool ReadFromStream(BinaryReader r)
{
DosHeader = ReadDosHeader(r);
if (DosHeader.e_magic != (int)ImageSignatureTypes.IMAGE_DOS_SIGNATURE)
{
r.Close();
return(false);
}
r.BaseStream.Seek((long)DosHeader.e_lfanew, SeekOrigin.Begin);
NTHeader = ReadNTHeader(r);
if (NTHeader.Signature != (int)ImageSignatureTypes.IMAGE_NT_SIGNATURE)
{
r.Close();
return(false);
}
{
uint maxpointer = 0;
uint exesize = 0;
for (int i = 0; i < NTHeader.FileHeader.NumberOfSections; ++i)
{
IMAGE_SECTION_HEADER data = new IMAGE_SECTION_HEADER();
{
data.NameBytes = r.ReadBytes(8);
data.PhysicalAddress = r.ReadUInt32();
data.VirtualAddress = r.ReadUInt32();
data.SizeOfRawData = r.ReadUInt32();
data.PointerToRawData = r.ReadUInt32();
data.PointerToRelocations = r.ReadUInt32();
data.PointerToLinenumbers = r.ReadUInt32();
data.NumberOfRelocations = r.ReadUInt16();
data.NumberOfLinenumbers = r.ReadUInt16();
data.Characteristics = r.ReadUInt32();
}
if (data.PointerToRawData > maxpointer)
{
maxpointer = data.PointerToRawData;
exesize = data.PointerToRawData + data.SizeOfRawData;
}
SectionHeaders.Add(data);
}
this.FileSize = exesize;
}
return(true);
}
public void TextSectionIsReadableExecutableAndHasCode()
{
var textSections = SectionHeaders.Where(item => item.NameString == ".text\0\0\0").ToArray();
if (textSections.Length < 1)
{
Assert.Inconclusive("Cannot run this test without .text section");
}
foreach (var sectionHeader in textSections)
{
Assert.That(
sectionHeader.Characteristics.HasFlag(SectionCharacteristics.ContainsCode),
".text does not contain code (section flags)"
);
Assert.That(sectionHeader.Characteristics.HasFlag(SectionCharacteristics.MemExecute), ".text is not executable (section flags)");
Assert.That(sectionHeader.Characteristics.HasFlag(SectionCharacteristics.MemRead), ".text is not readable (section flags)");
}
}
public void Parse(BinaryReader reader)
{
DOSHeader = DOSHeader.Parse(reader);
var dosStubSize = (int)(DOSHeader.CoffHeaderOffset - reader.BaseStream.Position);
_dosStubBytes = reader.ReadBytes(dosStubSize);
COFFHeader = COFFHeader.Parse(reader);
PEHeaderOffset = (uint)reader.BaseStream.Position;
PEHeader = PEHeader.Parse(reader);
for (var i = 0; i < COFFHeader.NumberOfSections; i++)
{
SectionHeaders.Add(PESectionHeader.Parse(reader));
}
var fillerSize = (int)(SectionHeaders[0].PointerToRawData - reader.BaseStream.Position);
_filler = reader.ReadBytes(fillerSize);
for (var i = 0; i < COFFHeader.NumberOfSections; i++)
{
var sectionBytes = reader.ReadBytes((int)SectionHeaders[i].SizeOfRawData);
Sections.Add(sectionBytes);
}
var remainingByteCount = (int)(reader.BaseStream.Length - reader.BaseStream.Position);
_remainingBytes = reader.ReadBytes(remainingByteCount);
// file ends here
// Parse Import Directory:
var importDirectoryEntry = PEHeader.DataDirectories[(int)DataDirectoryName.Import];
if (importDirectoryEntry.VirtualAddress > 0)
{
var importDirectoryFileOffset = GetOffsetFromRVA(importDirectoryEntry.VirtualAddress);
reader.BaseStream.Seek(importDirectoryFileOffset, SeekOrigin.Begin);
ImportDirectory = ImportDirectory.Parse(reader);
}
}
public void CanParseHeaderAndEntries()
{
var relocRVA = OptionalHeader.DataDirectories.BaseRelocationTable.VirtualAddress;
var relocSection = SectionHeaders.First(sec => sec.NameString.StartsWith(".reloc"));
var startFileOffset = relocSection.PointerToRawData + relocRVA - relocSection.VirtualAddress;
var reader = new ArrayStructReaderWriter(TestFile)
{
Offset = startFileOffset
};
var blockHeader = reader.Read <BaseRelocationBlockHeader>();
var noEntries = (blockHeader.BlockSize - 8) / 2;
var firstBlockEntry = reader.Read <BaseRelocationBlockEntry>();
var secondBlockEntry = reader.Read <BaseRelocationBlockEntry>();
Assert.AreEqual(0x19000, blockHeader.PageRVA);
Assert.AreEqual(12, noEntries);
Assert.AreEqual(0xA110, firstBlockEntry.Entry);
Assert.AreEqual(0x110, firstBlockEntry.Offset);
Assert.AreEqual(BaseRelocationType.ImageRelBasedDir64, firstBlockEntry.Type);
Assert.AreEqual(0xA440, secondBlockEntry.Entry);
}
private void ReadSections(int offset)
{
this.rva = new RVAManager();
int len = this.pe1.NumberOfSections;
this.sects = new SectionHeaders[len];
for (int i = 0; i < len; i++)
{
sects[i] = new SectionHeaders();
sects[i].ReadData(this.data, offset);
offset += 40;
this.rva.SetAddress(sects[i].PointerToRawData, sects[i].VirtualAddress);
sects[i].AppendTitle(string.Format(" \"{0}\"", Util.EscapeText(Util.GetASCIIString(sects[i].Name))));
}
}
public SectionHeader *GetChunk(SectionHeaders ident)
{
switch (ident)
{
case SectionHeaders.Form:
return((SectionHeader *)Form);
case SectionHeaders.General:
return((SectionHeader *)General);
case SectionHeaders.Options:
return((SectionHeader *)Options);
case SectionHeaders.Extensions:
return((SectionHeader *)Extensions);
case SectionHeaders.AudioGroup:
return((SectionHeader *)AudioGroup);
case SectionHeaders.Shaders:
return((SectionHeader *)Shaders);
case SectionHeaders.Timelines:
return((SectionHeader *)Timelines);
case SectionHeaders.DataFiles:
return((SectionHeader *)DataFiles);
case SectionHeaders.GNAL_Unk:
return((SectionHeader *)GNAL_Unk);
case SectionHeaders.Sounds:
return((SectionHeader *)Sounds);
case SectionHeaders.Sprites:
return((SectionHeader *)Sprites);
case SectionHeaders.Backgrounds:
return((SectionHeader *)Backgrounds);
case SectionHeaders.Paths:
return((SectionHeader *)Paths);
case SectionHeaders.Scripts:
return((SectionHeader *)Scripts);
case SectionHeaders.Fonts:
return((SectionHeader *)Fonts);
case SectionHeaders.Objects:
return((SectionHeader *)Objects);
case SectionHeaders.Rooms:
return((SectionHeader *)Rooms);
case SectionHeaders.TexturePage:
return((SectionHeader *)TexturePages);
case SectionHeaders.Code:
return((SectionHeader *)Code);
case SectionHeaders.Strings:
return((SectionHeader *)Strings);
case SectionHeaders.Textures:
return((SectionHeader *)Textures);
case SectionHeaders.Audio:
return((SectionHeader *)Audio);
case SectionHeaders.Functions:
return((SectionHeader *)Functions);
case SectionHeaders.Variables:
return((SectionHeader *)Variables);
default:
if (UnknownChunks.ContainsKey(ident))
{
return((SectionHeader *)UnknownChunks[ident]);
}
return(null);
}
}
private void FileOpen(string file)
{
// Set status bar location for the file.
tbStatusBarLocation.Text = file;
// Parse the PE file
if (!PeFile.IsPEFile(file))
{
ShowInvalidPeFileMsgBox();
return;
}
_peFile = new PeFile(file);
// Set all FileInfo fields.
FileInfo.SetFileInfo(_peFile);
// Set the DOS header fields
DosNtHeader.SetDosHeader(_peFile);
// Set the PE File fields
DosNtHeader.SetNtHeader(_peFile);
// Set the File header
FileHeaderDebug.SetFileHeader(_peFile);
// Set the Debug directory.
FileHeaderDebug.SetDebug(_peFile);
// Set the Optional header
OptionalHeader.SetOptionalHeader(_peFile);
// Set the imports.
Imports.SetImports(_peFile);
// Set the exports.
Exports.SetExports(_peFile);
// Set the resources.
Resource.SetResources(_peFile);
// Set the sections.
SectionHeaders.SetSections(_peFile);
// Set the Exception (only for x64)
Exceptions.SetException(_peFile);
// Set the Relocations.
Relocation.SetRelocations(_peFile);
// Set the Digital Signature information.
Signature.SetDigSignature(_peFile);
// Set the Bound Import directory.
DebugBoundImport.SetBoundImport(_peFile);
// Set the Delay Import descriptor.
DebugBoundImport.SetDelayImport(_peFile);
// Set the TLS directory.
TlsDirectory.SetTlsDirectory(_peFile);
// Set the Load Config Directory
LoadConfig.SetLoadConfig(_peFile);
// Set the Data Directory View
DirectoryView.SetDirectoryView(_peFile);
}
public uint GetPhysicalAddress(string sectionName)
{
return(SectionHeaders.First(i => i.NameString.Contains(sectionName)).PhysicalAddress);
}
public uint GetPhysicalAddressEnd(string sectionName)
{
return(SectionHeaders.Where(i => i.NameString.Contains(sectionName)).Select(o => o.SizeOfRawData + o.PhysicalAddress).First());
}
public ImageSection GetSectionByName(string name)
{
var header = SectionHeaders.FirstOrDefault(x => x.Name == name);
return(header != null ? header.Section : null);
}
public IEnumerable <ImageSection> GetSections()
{
return(SectionHeaders.Select(x => x.Section));
}
internal GMFile(GMFileContent f)
{
Content = f;
var orderList = new List <SectionHeaders>(f.HeaderOffsets.Length);
foreach (long headerOffset in f.HeaderOffsets)
{
SectionHeaders tag = ((SectionHeader *)((byte *)f.Form + headerOffset))->Identity;
if (tag != SectionHeaders.Form)
{
orderList.Add(tag);
}
}
ChunkOrder = orderList.ToArray();
if (f.General != null)
{
General = SectionReader.GetGeneralInfo(f);
}
if (f.Options != null)
{
Options = SectionReader.GetOptionInfo(f);
}
if (f.Globals != null)
{
Globals = SectionReader.GetGlobalInfo(f);
}
Sound = MkLazyArr(f.Sounds, i => SectionReader.GetSoundInfo(f, i));
if (f.TexturePages != null)
{
var toil = SectionReader.BuildTPAGOffsetIndexLUT(f);
Sprites = MkLazyArr(f.Sprites, i => SectionReader.GetSpriteInfo(f, i, toil));
}
Backgrounds = MkLazyArr(f.Backgrounds, i => SectionReader.GetBgInfo(f, i));
Paths = MkLazyArr(f.Paths, i => SectionReader.GetPathInfo(f, i));
Scripts = MkLazyArr(f.Scripts, i => SectionReader.GetScriptInfo(f, i));
Fonts = MkLazyArr(f.Fonts, i => SectionReader.GetFontInfo(f, i));
Objects = MkLazyArr(f.Objects, i => SectionReader.GetObjectInfo(f, i));
Rooms = MkLazyArr(f.Rooms, i => SectionReader.GetRoomInfo(f, i));
TexturePages = MkLazyArr(f.TexturePages, i => SectionReader.GetTexPageInfo(f, i));
Code = MkLazyArr(f.Code, i => Disassembler.DisassembleCode(f, i));
Strings = MkLazyArr(f.Strings, i => SectionReader.GetStringInfo(f, i));
Textures = MkLazyArr(f.Textures, i => SectionReader.GetTextureInfo(f, i));
Audio = MkLazyArr(f.Audio, i => SectionReader.GetAudioInfo(f, i));
AudioGroups = MkLazyArr(f.AudioGroup, i => SectionReader.GetAudioGroupInfo(f, i));
Extensions = MkLazyArr(f.Extensions, i => SectionReader.GetExtensionInfo(f, i));
Shaders = MkLazyArr(f.Shaders, i => SectionReader.GetShaderInfo(f, i));
Timelines = MkLazyArr(f.Timelines, i => SectionReader.GetTimelineInfo(f, i));
AudioSoundMap = new Dictionary <uint, uint>();
if (f.Sounds != null)
{
for (uint i = 0; i < Sound.Length; i++)
{
var s = Sound[i];
if ((s.IsEmbedded || s.IsCompressed) && s.AudioID != -1 && s.GroupID == 0)
{
AudioSoundMap[(uint)s.AudioID] = i;
}
}
}
if (f.General == null)
{
return;
}
try
{
// TODO: do this in a better way
var vars = General.IsOldBCVersion
? SectionReader.GetRefDefs(f, f.Variables)
: SectionReader.GetRefDefsWithOthers(f, f.Variables);
var fns = General.IsOldBCVersion
? SectionReader.GetRefDefs(f, f.Functions)
: SectionReader.GetRefDefsWithLength(f, f.Functions);
var varacc = Disassembler.GetReferenceTable(f, vars);
var fnacc = Disassembler.GetReferenceTable(f, fns);
RefData = new RefData
{
Variables = vars,
Functions = fns,
VarAccessors = varacc,
FuncAccessors = fnacc
};
if (f.Functions->Entries.NameOffset * 12 < f.Functions->Header.Size)
{
FunctionLocals = SectionReader.GetFunctionLocals(f, f.Functions);
}
if (f.Variables != null && !General.IsOldBCVersion)
{
VariableExtra = new uint[]
{
((uint *)&f.Variables->Entries)[0],
((uint *)&f.Variables->Entries)[1],
((uint *)&f.Variables->Entries)[2]
}
}
;
}
catch (Exception e)
{
Console.Error.WriteLine("Warning: Can't figure out RefDef pairs. Exception:");
Console.Error.WriteLine(e);
}
}
public WDC3Reader(Stream stream)
{
using (var reader = new BinaryReader(stream, Encoding.UTF8))
{
if (reader.BaseStream.Length < HeaderSize)
{
throw new InvalidDataException("WDC3 file is corrupted!");
}
uint magic = reader.ReadUInt32();
if (magic != WDC3FmtSig)
{
throw new InvalidDataException("WDC3 file is corrupted!");
}
RecordsCount = reader.ReadInt32();
FieldsCount = reader.ReadInt32();
RecordSize = reader.ReadInt32();
StringTableSize = reader.ReadInt32();
TableHash = reader.ReadUInt32();
LayoutHash = reader.ReadUInt32();
MinIndex = reader.ReadInt32();
MaxIndex = reader.ReadInt32();
Locale = reader.ReadInt32();
Flags = (DB2Flags)reader.ReadUInt16();
IdFieldIndex = reader.ReadUInt16();
int totalFieldsCount = reader.ReadInt32();
PackedDataOffset = reader.ReadInt32(); // Offset within the field where packed data starts
lookupColumnCount = reader.ReadInt32(); // count of lookup columns
field_info_size = reader.ReadInt32(); // 24 * NumFields bytes, describes column bit packing, {ushort recordOffset, ushort size, uint additionalDataSize, uint compressionType, uint packedDataOffset or commonvalue, uint cellSize, uint cardinality}[NumFields], sizeof(DBC2CommonValue) == 8
commonDataSize = reader.ReadInt32();
palletDataSize = reader.ReadInt32(); // in bytes, sizeof(DBC2PalletValue) == 4
SectionsCount = reader.ReadInt32();
if (SectionsCount == 0 || RecordsCount == 0)
{
return;
}
//section headers
SectionHeaders = reader.ReadArray <SectionHeaderWDC3>(SectionsCount).ToList();
m_sections = SectionHeaders.OfType <IEncryptableDatabaseSection>().ToList();
// field meta data
field_structure_data = reader.ReadArray <FieldMetaData>(FieldsCount);
// column meta data
ColumnMeta = reader.ReadArray <ColumnMetaData>(FieldsCount);
// pallet data
PalletData = new Value32[ColumnMeta.Length][];
for (int i = 0; i < ColumnMeta.Length; i++)
{
if (ColumnMeta[i].CompressionType == CompressionType.Pallet || ColumnMeta[i].CompressionType == CompressionType.PalletArray)
{
PalletData[i] = reader.ReadArray <Value32>((int)ColumnMeta[i].AdditionalDataSize / 4);
}
}
// common data
CommonData = new Dictionary <int, Value32> [ColumnMeta.Length];
for (int i = 0; i < ColumnMeta.Length; i++)
{
if (ColumnMeta[i].CompressionType == CompressionType.Common)
{
var commonValues = new Dictionary <int, Value32>((int)ColumnMeta[i].AdditionalDataSize / 8);
CommonData[i] = commonValues;
for (int j = 0; j < ColumnMeta[i].AdditionalDataSize / 8; j++)
{
commonValues[reader.ReadInt32()] = reader.Read <Value32>();
}
}
}
//section_data
int StringTableSizeCounter = 0, RecordCountCounter = 0;
//foreach (var sectionheader in SectionHeaders)
//{
reader.BaseStream.Position = SectionHeaders[0].FileOffset;
if (!Flags.HasFlagExt(DB2Flags.Sparse)) //'no offset map'
{
// records data
RecordsData = reader.ReadBytes(SectionHeaders[0].NumRecords * RecordSize);
Array.Resize(ref RecordsData, RecordsData.Length + 8); // pad with extra zeros so we don't crash when reading
// string data
if (StringTable == null)
{
StringTable = new Dictionary <long, string>(SectionHeaders[0].StringTableSize / 0x20);
}
for (int i = 0; i < SectionHeaders[0].StringTableSize;)
{
long oldPos = reader.BaseStream.Position;
StringTable[i + StringTableSizeCounter] = reader.ReadCString();
i += (int)(reader.BaseStream.Position - oldPos);
}
StringTableSizeCounter += SectionHeaders[0].StringTableSize;
}
else //'Has offset map'
{
// sparse data with inlined strings
RecordsData = reader.ReadBytes(SectionHeaders[0].OffsetRecordsEndOffset - SectionHeaders[0].FileOffset);
if (reader.BaseStream.Position != SectionHeaders[0].OffsetRecordsEndOffset)
{
throw new Exception("reader.BaseStream.Position != section.OffsetRecordsEndOffset");
}
}
// skip encrypted sections => has tact key + record data is zero filled
if (SectionHeaders[0].TactKeyLookup != 0 && Array.TrueForAll(RecordsData, x => x == 0))
{
RecordCountCounter += SectionHeaders[0].NumRecords;
return;
}
// id_list_data
id_list_data = reader.ReadArray <int>(SectionHeaders[0].IndexDataSize / 4);
// fix zero-filled index data
if (id_list_data.Length > 0 && id_list_data.All(x => x == 0))
{
id_list_data = Enumerable.Range(MinIndex + RecordCountCounter, SectionHeaders[0].NumRecords).ToArray();
}
// copy table entry data , duplicate rows data
if (SectionHeaders[0].CopyTableCount > 0)
{
if (CopyData == null)
{
CopyData = new Dictionary <int, int>();
}
for (int i = 0; i < SectionHeaders[0].CopyTableCount; i++)
{
CopyData[reader.ReadInt32()] = reader.ReadInt32(); //id_of_new_row, id_of_copied_row
}
}
// offset map entry data
if (SectionHeaders[0].OffsetMapIDCount > 0)
{
// HACK unittestsparse is malformed and has sparseIndexData first
if (TableHash == 145293629)
{
reader.BaseStream.Position += 4 * SectionHeaders[0].OffsetMapIDCount;
}
offset_map_Entries = reader.ReadArray <offset_map_entry>(SectionHeaders[0].OffsetMapIDCount).ToList();
}
// reference/relationship data
refData = new ReferenceData();
if (SectionHeaders[0].ParentLookupDataSize > 0)
{
refData.NumRecords = reader.ReadInt32();
refData.MinId = reader.ReadInt32();
refData.MaxId = reader.ReadInt32();
var entries = reader.ReadArray <ReferenceEntry>(refData.NumRecords);
for (int i = 0; i < entries.Length; i++)
{
refData.Entries[entries[i].Index] = entries[i].Id;
}
}
//offset_map_id_list
if (SectionHeaders[0].OffsetMapIDCount > 0)
{
int[] offset_map_id_listdata = reader.ReadArray <int>(SectionHeaders[0].OffsetMapIDCount);
if (SectionHeaders[0].IndexDataSize > 0 && id_list_data.Length != offset_map_id_listdata.Length)
{
throw new Exception("m_indexData.Length != sparseIndexData.Length");
}
id_list_data = offset_map_id_listdata;
}
//loop and add field data to create datarow
int position = 0;
for (int i = 0; i < SectionHeaders[0].NumRecords; i++)
{
BitReader bitReader = new BitReader(RecordsData)
{
Position = 0
};
if (Flags.HasFlagExt(DB2Flags.Sparse))
{
bitReader.Position = position;
position += offset_map_Entries[i].Size * 8;
}
else
{
bitReader.Offset = i * RecordSize;
}
refData.Entries.TryGetValue(i, out int refId);
IDBRow rec = new WDC3Row(this, bitReader, SectionHeaders[0].IndexDataSize != 0 ? id_list_data[i] : -1, refId, i + RecordCountCounter);
_Records.Add(_Records.Count, rec);
}
RecordCountCounter += SectionHeaders[0].NumRecords;
//}
long pos = reader.BaseStream.Position;
long len = reader.BaseStream.Length;
NoParseRecordsData = reader.ReadBytes((int)(len - pos));
}
}
private string[] GetSectionNames() => SectionHeaders.Select(item => item.NameString).ToArray();
public void LastSectionIsInFile()
{
Assert.GreaterOrEqual(TestFile.Length, SectionHeaders.Max(sec => sec.PointerToRawData + sec.SizeOfRawData));
}
