public NameTableReader(SpanStream r)
{
UInt32 magic = r.ReadUInt32();
if (magic != MAGIC)
{
throw new InvalidDataException($"Invalid verHdr magic 0x{magic:X}");
}
Version = r.ReadEnum <NameTableVersion>();
switch (Version)
{
case NameTableVersion.Hash:
hasher = HasherV1.HashData;
break;
case NameTableVersion.HashV2:
hasher = HasherV2.HashData;
break;
}
byte[] buf = Deserializers.ReadBuffer(r);
rdr = new SpanStream(buf);
Indices = Deserializers.ReadArray <UInt32>(r);
NumberOfElements = r.ReadUInt32();
}
public NameIndexTableReader(SpanStream r)
{
byte[] stringTableData = Deserializers.ReadBuffer(r);
rdr = new SpanStream(stringTableData);
Offset_Index = Deserializers.ReadMap <uint, uint>(r);
MaxIndices = r.ReadUInt32();
// reverse of Offset_Index
Index_Offset = Offset_Index.ToDictionary(x => x.Value, x => x.Key);
}
public TPIHashReader(IServiceContainer ctx, byte[] hashData) : base(hashData)
{
TPIReader tpi = ctx.GetService <TPIReader>();
TPIHash hash = tpi.Header.Hash;
switch (hash.HashKeySize)
{
case sizeof(UInt16):
case sizeof(UInt32):
break;
default:
throw new InvalidDataException();
}
if (hash.TypeOffsets.Size > 0)
{
Position = hash.TypeOffsets.Offset;
uint NumTiPairs = (uint)(hash.TypeOffsets.Size / Marshal.SizeOf <TIOffset>());
for (int i = 1; i < NumTiPairs; i++)
{
TIOffset tiOff = Read <TIOffset>();
TypeIndexToOffset.Add(tiOff.TypeIndex, tiOff.Offset);
}
}
if (hash.HashValues.Size > 0)
{
Position = hash.HashValues.Offset;
uint NumHashValues = hash.HashValues.Size / sizeof(UInt32);
RecordHashValues = PerformAt(hash.HashValues.Offset, () => {
return(Enumerable.Range(1, (int)NumHashValues)
.Select(_ => ReadUInt32())
.ToArray());
});
}
if (hash.HashHeadList.Size > 0)
{
Position = hash.HashHeadList.Offset;
NameIndexToTypeIndex = Deserializers.ReadMap <UInt32, UInt32>(this);
}
}
public UdtNameTableReader(IServiceContainer ctx, byte[] namesData) : base(namesData)
{
this.Tpi = ctx.GetService <TPIReader>();
this.resolver = ctx.GetService <TypeResolver>();
Magic = ReadUInt32();
if (Magic != MAGIC)
{
throw new InvalidDataException();
}
Version = ReadEnum <UdtNameTableVersion>();
data = Deserializers.ReadBuffer(this);
rdr = new SpanStream(data);
NameIndices = Deserializers.ReadArray <uint>(this);
NumberOfNameIndices = ReadUInt32();
//BuildTypeMap();
}
public PdbStreamReader(byte[] nameMapData) : base(nameMapData)
{
Version = ReadEnum <PDBPublicVersion>();
Signature = ReadUInt32();
NumberOfUpdates = ReadUInt32();
if (Version < PDBPublicVersion.VC4 || Version > PDBPublicVersion.VC140)
{
return;
}
if (Version > PDBPublicVersion.VC70Dep)
{
NewSignature = Read <Guid>();
}
NameTable = Deserializers.ReadNameIndexTable(this);
bool flagContinue = true;
while (flagContinue && Position + sizeof(uint) < Length)
{
UInt32 signature = ReadUInt32();
if (Enum.IsDefined(typeof(PDBPublicVersion), signature))
{
PDBPublicVersion version = (PDBPublicVersion)signature;
switch (version)
{
case PDBPublicVersion.VC110:
case PDBPublicVersion.VC140:
flagContinue = false;
break;
}
}
else if (Enum.IsDefined(typeof(PDBFeature), signature))
{
}
}
}
public ECReader(SpanStream stream) : base(stream)
{
NameTable = Deserializers.ReadNameTable(this);
}
