public void Save(VirtualWriter wtr, Rva adr)
{
wtr.SetPosition(adr);
wtr.Write(sig);
wtr.Write(maVer);
wtr.Write(miVer);
wtr.Write(res);
wtr.Write((ver.Length + 3) & ~3);
wtr.Write(Encoding.ASCII.GetBytes(ver));
wtr.Write(new byte[((ver.Length + 1 + 3) & ~3) - ver.Length]);
wtr.Write(f);
wtr.Write((ushort)Items.Count);
uint datOffset = (uint)(20 + ((ver.Length + 3) & ~3) + this.Count * 8);
foreach (MetadataStream str in Items)
{
datOffset += (uint)((str.Name.Length + 1 + 3) & ~3);
}
foreach (MetadataStream str in Items)
{
wtr.Write(datOffset);
datOffset += (uint)((str.Length + 3) & ~3);
wtr.Write((uint)((str.Length + 3) & ~3));
wtr.Write(Encoding.ASCII.GetBytes(str.Name));
wtr.Write(new byte[((str.Name.Length + 1 + 3) & ~3) - str.Name.Length]);
}
foreach (MetadataStream str in Items)
{
wtr.Write(str.Data);
wtr.Write(new byte[((str.Length + 3) & ~3) - str.Length]);
}
}
protected override void InsertItem(int index, CLRData item)
{
if (lding && (datloc == 0 || datloc > item.Address))
{
datloc = item.Address;
}
base.InsertItem(index, item);
}
public void UpdateRva(Rva old, Rva @new)
{
IEnumerator <CLRData> etr = base.GetEnumerator();
while (etr.MoveNext() && etr.Current.Address != old)
{
;
}
etr.Current.Address = @new;
}
public void Save(VirtualWriter wtr, Rva adr)
{
wtr.SetPosition(adr);
foreach (FixupEntry i in Items)
{
wtr.Write(i.VTable);
wtr.Write((ushort)i.Size);
wtr.Write((ushort)i.Type);
}
}
public void Load(VirtualReader rdr, Rva adr)
{
rdr.SetPosition(adr);
sig = rdr.ReadUInt32();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
res = rdr.ReadUInt32();
uint len = rdr.ReadUInt32();
ver = new string(rdr.ReadChars((int)len)).Trim('\0');
f = rdr.ReadUInt16();
ushort s = rdr.ReadUInt16();
for (int i = 0; i < s; i++)
{
MetadataStream str = new MetadataStream(this);
Rva datAdr = adr + rdr.ReadUInt32();
Rva datSze = rdr.ReadUInt32();
str.Name = "";
str.File = rdr.BaseStream.File;
for (int ii = 0; ii < 32; ii++)
{
byte[] bs = rdr.ReadBytes(4);
foreach (byte b in bs)
{
if (b != 0)
{
str.Name += (char)b;
}
else
{
break;
}
}
if (bs[3] == '\0')
{
break;
}
}
if (str.Type != MetadataStreamType.Unknown)
{
tStrs[str.Type] = str;
}
nStrs[str.Name] = str;
rdr.SaveLocation();
rdr.SetPosition(datAdr);
str.Data = rdr.ReadBytes((int)datSze.Value);
rdr.LoadLocation();
Items.Add(str);
}
foreach (MetadataStream i in Items)
{
i.Load();
}
}
protected override void LoadInternal(VirtualReader rdr)
{
c = rdr.ReadUInt32();
stamp = rdr.ReadStamp();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
t = (DebugType)rdr.ReadUInt32();
s = rdr.ReadUInt32();
this.adr = rdr.ReadRva();
ptr = rdr.ReadUInt32();
}
internal void Load(VirtualReader rdr)
{
for (int i = 0; i < dd.NumberOfNamePointers; i++)
{
Rva name = rdr.ReadRva();
rdr.SaveLocation();
rdr.BaseStream.Position = name;
this.Add(rdr.ReadString());
rdr.LoadLocation();
}
}
public bool ContainsAddress(Rva rva)
{
foreach (CLRData i in Items)
{
if (i.Address == rva)
{
return(true);
}
}
return(false);
}
public DataDirectoryType Occupied(Rva rva)
{
foreach (DataDirectoryEntry e in file.OptionalHeader.DataDirectories)
{
if (rva > e.Address && rva < (e.Address + e.Size))
{
return(e.Type);
}
}
return(DataDirectoryType.Reserved);
}
internal void Load(VirtualReader rdr)
{
Rva datAdr = rdr.ReadRva();
uint s = rdr.ReadUInt32();
cp = rdr.ReadUInt32();
rdr.ReadUInt32();
rdr.SaveLocation();
rdr.SetPosition(datAdr);
dat = rdr.ReadBytes((int)s);
rdr.LoadLocation();
}
protected override void SaveInternal(VirtualWriter wtr)
{
root = Location.Address;
ComputeOffset();
wtr.Write(c);
wtr.WriteStamp(stamp);
wtr.Write(maVer);
wtr.Write(miVer);
wtr.Write(noName);
wtr.Write(noID);
foreach (ResourceEntry i in es)
{
if ((i.Type & EntryType.Name) == EntryType.Name)
{
uint strOffset = strO[i.Name];
wtr.Write(strOffset | 0x80000000);
wtr.SaveLocation();
wtr.SetPosition(root + strOffset);
wtr.WriteUnicodeString(i.Name);
wtr.LoadLocation();
}
else if ((i.Type & EntryType.ID) == EntryType.ID)
{
wtr.Write(i.ID);
}
if ((i.Type & EntryType.Subdirectory) == EntryType.Subdirectory)
{
uint dirOffset = dirO[i.Data as Subdirectory];
wtr.Write(dirOffset | 0x80000000);
wtr.SaveLocation();
wtr.SetPosition(root + dirOffset);
(i.Data as Subdirectory).Save(wtr, this);
wtr.LoadLocation();
}
else if ((i.Type & EntryType.DataEntry) == EntryType.DataEntry)
{
uint dateOffset = dateO[i.Data as DataEntry];
wtr.Write(dateOffset);
wtr.SaveLocation();
wtr.SetPosition(root + dateOffset);
(i.Data as DataEntry).Save(wtr, this);
wtr.LoadLocation();
}
}
}
public CLRData this[Rva rva]
{
get
{
foreach (CLRData i in Items)
{
if (i.Address == rva)
{
return(i);
}
}
return(null);
}
}
public bool Resolve(Rva rva, out Section sect, out int idx)
{
foreach (Section s in this)
{
if (rva >= s.VirtualAddress && rva < (s.VirtualAddress + s.VirtualSize))
{
sect = s;
idx = (int)(rva - s.VirtualAddress);
return(true);
}
}
sect = null;
idx = 0;
return(false);
}
internal void Load(VirtualReader rdr)
{
pr = rdr.ReadRva();
s = rdr.ReadUInt32();
uint c = (s - 8) / 2;
for (int i = 0; i < c; i++)
{
RelocationEntry e = new RelocationEntry();
ushort item = rdr.ReadUInt16();
e.Type = (RelocationType)((item & 0xf000U) >> 12);
e.Offest = (item & 0x0fffU) + pr;
this.Add(e);
}
}
public Rva GetNewRva(Rva key)
{
if (key == 0)
{
return(key);
}
Rva ret = DatasLocation;
IEnumerator <CLRData> etr = base.GetEnumerator();
while (etr.MoveNext() && etr.Current.Address != key)
{
ret += (uint)((etr.Current.Data.Length + 3) & ~3);
}
return((uint)(ret));
}
public override long Seek(long offset, SeekOrigin origin)
{
switch (origin)
{
case SeekOrigin.Begin:
rva = (Rva)offset; break;
case SeekOrigin.Current:
rva += (Rva)offset; break;
case SeekOrigin.End:
throw new InvalidOperationException();
}
return(rva);
}
public override void Read(PeReader rdr)
{
rdr.SetPosition(hdr.StandardFieldsOffset);
rdr.ReadUInt16();
maL = rdr.ReadByte();
miL = rdr.ReadByte();
sC = rdr.ReadUInt32();
sI = rdr.ReadUInt32();
sU = rdr.ReadUInt32();
entry = rdr.ReadUInt32();
bc = rdr.ReadUInt32();
if (Magic != ExecutableType.PE32Plus)
{
bd = rdr.ReadUInt32();
}
}
public void Load(VirtualReader rdr, Rva adr, uint size)
{
rdr.SetPosition(adr);
while (rdr.BaseStream.Position - adr < size)
{
FixupEntry e = new FixupEntry();
e.VTable = rdr.ReadRva();
e.Size = rdr.ReadUInt16();
e.Type = (FixupType)rdr.ReadUInt16();
rdr.SaveLocation();
rdr.SetPosition(e.VTable);
d.Datas.Add(new CLRData()
{
Address = e.VTable, Data = rdr.ReadBytes((int)e.Size * 4)
});
rdr.LoadLocation();
this.Add(e);
}
}
internal void Save(VirtualWriter wtr)
{
Rva fdrAdr = (Rva)wtr.GetPosition() + GetPointersSize();
foreach (ExportAddressEntry i in Items)
{
if (i.Type == ExportAddressType.RealExport)
{
wtr.Write(i.Address);
}
else
{
wtr.Write(fdrAdr);
fdrAdr += (uint)i.Forwarder.Length + 1;
wtr.SaveLocation();
wtr.SetPosition(fdrAdr);
wtr.Write(i.Forwarder);
wtr.LoadLocation();
}
}
}
protected override void SaveInternal(VirtualWriter wtr)
{
Rva baseAdr = wtr.GetPosition();
wtr.Write(f);
wtr.WriteStamp(stamp);
wtr.Write((ushort)maVer);
wtr.Write((ushort)miVer);
wtr.Write(baseAdr + 40);
wtr.Write((uint)bas);
wtr.Write((uint)noAdr);
wtr.Write((uint)noName);
Rva adrsAdr = (Rva)(baseAdr + 40 + n.Length + 1);
Rva nptAdr = adrsAdr + adr.GetPointersSize() + adr.GetForwardersSize();
Rva otAdr = nptAdr + nt.GetPointersSize() + nt.GetDataSize();
wtr.Write(adrsAdr);
wtr.Write(nptAdr);
wtr.Write(otAdr);
wtr.SetPosition(baseAdr + 40);
wtr.Write(n);
wtr.SetPosition(adrsAdr);
adr.Save(wtr);
wtr.SetPosition(nptAdr);
uint nameOffset = nt.GetPointersSize();
foreach (string str in nt)
{
wtr.Write(nptAdr + nameOffset);
nameOffset += (uint)str.Length + 1;
}
nt.Save(wtr);
wtr.SetPosition(otAdr);
ot.Save(wtr);
}
protected override void LoadInternal(VirtualReader rdr)
{
f = rdr.ReadUInt32();
stamp = rdr.ReadStamp();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
Rva nr = rdr.ReadRva();
bas = rdr.ReadUInt32();
noAdr = rdr.ReadUInt32();
noName = rdr.ReadUInt32();
Rva adrPtr = rdr.ReadRva();
Rva ntPtr = rdr.ReadRva();
Rva otPtr = rdr.ReadRva();
rdr.SaveLocation();
rdr.SetPosition(nr);
n = rdr.ReadString();
rdr.LoadLocation();
rdr.SaveLocation();
rdr.SetPosition(adrPtr);
adr = new ExportAddressTable(this);
adr.Load(rdr);
rdr.LoadLocation();
rdr.SaveLocation();
rdr.SetPosition(ntPtr);
nt = new ExportNameTable(this);
nt.Load(rdr);
rdr.LoadLocation();
rdr.SaveLocation();
rdr.SetPosition(otPtr);
ot = new ExportOrdinalTable(this);
ot.Load(rdr);
rdr.LoadLocation();
}
protected override void LoadInternal(VirtualReader rdr)
{
ulong bas = rdr.BaseStream.File.OptionalHeader.WindowsSpecificFields.ImageBase;
if (rdr.BaseStream.File.OptionalHeader.Type == OptionalHeader.ExecutableType.PE32Plus)
{
isPe32Plus = true;
s = (uint)(rdr.ReadUInt64() - bas);
e = (uint)(rdr.ReadUInt64() - bas);
idx = (uint)(rdr.ReadUInt64() - bas);
cb = (uint)(rdr.ReadUInt64() - bas);
}
else
{
isPe32Plus = false;
s = (uint)(rdr.ReadUInt32() - bas);
e = (uint)(rdr.ReadUInt32() - bas);
idx = (uint)(rdr.ReadUInt32() - bas);
cb = (uint)(rdr.ReadUInt32() - bas);
}
sz = rdr.ReadUInt32();
c = rdr.ReadUInt32();
}
internal void Load(VirtualReader rdr)
{
for (int i = 0; i < dd.AddressTableEntries; i++)
{
ExportAddressEntry d = new ExportAddressEntry();
Rva rva = rdr.ReadRva();
d.Address = rva;
if (!(rva > dd.Location.Address && rva < dd.Location.Address + dd.Location.Size))
{
d.Type = ExportAddressType.RealExport;
d.Forwarder = "";
}
else
{
d.Type = ExportAddressType.ForwarderExport;
rdr.SaveLocation();
rdr.SetPosition(rva);
d.Forwarder = rdr.ReadString();
rdr.LoadLocation();
}
this.Items.Add(d);
}
}
protected override void LoadInternal(VirtualReader rdr)
{
ImportDirectoryEntry entry;
while (true)
{
entry = new ImportDirectoryEntry(this);
Rva ltAdr = rdr.ReadRva();
entry.DateTimeStamp = rdr.ReadStamp();
entry.ForwarderChain = rdr.ReadUInt32();
Rva nAdr = rdr.ReadRva();
Rva atAdr = rdr.ReadRva();
if (ltAdr == 0 && atAdr == 0 && nAdr == 0)
{
break;
}
rdr.SaveLocation();
rdr.SetPosition(ltAdr);
entry.LookupTable = new ImportFunctionTable(entry);
entry.LookupTable.Load(rdr, false);
rdr.LoadLocation();
rdr.SaveLocation();
rdr.SetPosition(nAdr);
entry.Name = rdr.ReadString();
rdr.LoadLocation();
rdr.SaveLocation();
rdr.SetPosition(atAdr);
entry.AddressTable = new ImportFunctionTable(entry);
entry.AddressTable.Load(rdr, StampsHelper.UIntFromStamp(entry.DateTimeStamp) == 0xffffffff);
rdr.LoadLocation();
items.Add(entry);
}
}
public void SetPosition(Rva pos)
{
BaseStream.Position = pos;
}
protected override void LoadInternal(VirtualReader rdr)
{
s = rdr.ReadUInt32();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
dats = new CLRDatas(this);
dats.IsLoading = true;
Rva mdAdr = rdr.ReadRva();
uint mdSze = rdr.ReadUInt32();
f = (RuntimeFlags)rdr.ReadUInt32();
if ((f & RuntimeFlags.NativeEntryPoint) == RuntimeFlags.NativeEntryPoint)
{
Rva ep = rdr.ReadRva();
rdr.SaveLocation();
rdr.SetPosition(ep);
byte[] ec = NativeHelper.GetNativeCodes(rdr);
rdr.LoadLocation();
e = ep;
dats.Add(new CLRData()
{
Address = ep, Data = ec
});
}
else
{
t = rdr.ReadUInt32();
}
Rva resAdr = rdr.ReadRva();
uint resSze = rdr.ReadUInt32();
Rva snAdr = rdr.ReadRva();
uint snSze = rdr.ReadUInt32();
Rva cmAdr = rdr.ReadRva();
uint cmSze = rdr.ReadUInt32();
Rva vtAdr = rdr.ReadRva();
uint vtSze = rdr.ReadUInt32();
Rva eatAdr = rdr.ReadRva();
uint eatSze = rdr.ReadUInt32();
Rva mnAdr = rdr.ReadRva();
uint mnSze = rdr.ReadUInt32();
rdr.SetPosition(resAdr);
res = rdr.ReadBytes((int)resSze);
rdr.SetPosition(snAdr);
sn = rdr.ReadBytes((int)snSze);
rdr.SetPosition(cmAdr);
cm = rdr.ReadBytes((int)cmSze);
rdr.SetPosition(eatAdr);
eat = rdr.ReadBytes((int)eatSze);
rdr.SetPosition(mnAdr);
mn = rdr.ReadBytes((int)mnSze);
vt = new VTableFixups(this);
vt.Load(rdr, vtAdr, vtSze);
md = new MetadataRoot(this);
md.Load(rdr, mdAdr);
dats.IsLoading = false;
// Save the read info
MetadataDirEntry = new CLRDataDirectoryEntry("MetaData", mdAdr, mdSze);
ResourceDirEntry = new CLRDataDirectoryEntry("Resources", resAdr, resSze);
StrongNameDirEntry = new CLRDataDirectoryEntry("Strong Name Signature", snAdr, snSze);
CodeManagerTableDirEntry = new CLRDataDirectoryEntry("Code Manager Table", cmAdr, cmSze);
VTableFixupsDirEntry = new CLRDataDirectoryEntry("VTable Fixups", vtAdr, vtSze);
ExportAddressTableJumpsDirEntry = new CLRDataDirectoryEntry("Export Address Table Jumps", eatAdr, eatSze);
ManagedNativeHeaderDirEntry = new CLRDataDirectoryEntry("Managed Native Header", mnAdr, mnSze);
}
public override string ToString()
{
return(base.ToString() + " " + Name + " points to {" + Rva.ToString("X8") + " - " + (Rva + Size).ToString("X8") + "}");
}
void ReadRvaData(MetadataTable tbl, MetadataReader mdRdr, List <Rva> rvas, MetadataRowCollection rows)
{
List <Rva> sorted = new List <Rva>(rvas);
sorted.Sort();
for (int i = 0; i < rvas.Count; i++)
{
Rva rva = rvas[i];
MetadataRow r = rows[i + 1];
byte[] dat = null;
VirtualReader rdr = new VirtualReader(mdRdr.BaseStream.File.SectionHeaders.GetVirtualStream());
if (tbl.Type == TableType.FieldRVA)
{
MetadataRoot root = tbl.Heap.Stream.Root;
rdr.SetPosition(rva);
MetadataRow fd = (r["Field"] as TableToken).ResolveRow();
FieldSig sig = new FieldSig();
SignatureReader sigRdr = new SignatureReader(new MetadataReader(root[MetadataStreamType.Blob]));
sigRdr.BaseStream.Position = (fd["Signature"] as BlobToken).Token.Index;
sig.Read(sigRdr);
int c = 0;
switch (sig.Type.Element)
{
case ElementType.Boolean:
case ElementType.UInt8:
case ElementType.Int8:
c = 1; break;
case ElementType.UInt16:
case ElementType.Int16:
case ElementType.Char:
c = 2; break;
case ElementType.UInt32:
case ElementType.Int32:
case ElementType.Single:
c = 4; break;
case ElementType.UInt64:
case ElementType.Int64:
case ElementType.Double:
c = 8; break;
case ElementType.ValueType:
TableToken vt = (sig.Type as VALUETYPE).Type;
foreach (MetadataRow cl in tbl.Heap[TableType.ClassLayout])
{
if (cl["Parent"] == vt)
{
c = (int)cl["ClassSize"];
break;
}
}
break;
default:
throw new InvalidOperationException("ReadRvaData");
}
dat = rdr.ReadBytes(c);
}
else if (tbl.Type == TableType.MethodDef && rva != 0)
{
//MethodBody bdy;
//if (((MethodImplAttributes)r["ImplFlags"] & MethodImplAttributes.Native) == MethodImplAttributes.Native)
//{
// bdy = new NativeMethodBody(r);
//}
//else
//{
// bdy = new ManagedMethodBody(r);
//}
//rdr.SetPosition(rva);
//bdy.Load(rdr);
//rdr.SetPosition(rva);
//dat = rdr.ReadBytes((int)bdy.Size);
int idx;
Rva next;
if ((idx = sorted.IndexOf(rva)) == sorted.Count - 1)
{
CLRDirectory root = tbl.Heap.Stream.Root.Directory;
Rva now;
next = uint.MaxValue;
rdr.SetPosition(root.Location.Address);
rdr.BaseStream.Seek(0x8, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0xC, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
}
else
{
next = sorted[idx + 1];
}
rdr.SetPosition(rva);
dat = rdr.ReadBytes((int)(next - rva));
}
if (!tbl.Heap.Stream.Root.Directory.Datas.ContainsAddress(rva) && dat != null)
{
tbl.Heap.Stream.Root.Directory.Datas.Add(new CLRData()
{
Address = rva, Data = dat
});
}
}
}
internal void Load(VirtualReader rdr, Rva root)
{
c = rdr.ReadUInt32();
stamp = rdr.ReadStamp();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
noName = rdr.ReadUInt16();
noID = rdr.ReadUInt16();
for (int i = 0; i < noName; i++)
{
ResourceEntry e = new ResourceEntry();
e.Type = EntryType.Name;
Rva nRva = rdr.ReadRva() & ~0x80000000;
rdr.SaveLocation();
rdr.SetPosition(nRva + root);
e.Name = rdr.ReadUnicodeString();
rdr.LoadLocation();
Rva datAdr = rdr.ReadUInt32();
if ((datAdr & 0x80000000) == 0x80000000)
{
datAdr &= ~0x80000000;
e.Type |= EntryType.Subdirectory;
e.Data = new Subdirectory(e);
rdr.SaveLocation();
rdr.SetPosition(datAdr + root);
(e.Data as Subdirectory).Load(rdr, root);
rdr.LoadLocation();
}
else
{
e.Type |= EntryType.DataEntry;
e.Data = new DataEntry(e);
rdr.SaveLocation();
rdr.SetPosition(datAdr + root);
(e.Data as DataEntry).Load(rdr);
rdr.LoadLocation();
}
this.Add(e);
}
for (int i = 0; i < noID; i++)
{
ResourceEntry e = new ResourceEntry();
e.Type = EntryType.ID;
e.ID = rdr.ReadUInt32() & ~0x80000000;
Rva datAdr = rdr.ReadUInt32();
if ((datAdr & 0x80000000) == 0x80000000)
{
datAdr &= ~0x80000000;
e.Type |= EntryType.Subdirectory;
e.Data = new Subdirectory(e);
rdr.SaveLocation();
rdr.SetPosition(datAdr + root);
(e.Data as Subdirectory).Load(rdr, root);
rdr.LoadLocation();
}
else
{
e.Type |= EntryType.DataEntry;
e.Data = new DataEntry(e);
rdr.SaveLocation();
rdr.SetPosition(datAdr + root);
(e.Data as DataEntry).Load(rdr);
rdr.LoadLocation();
}
this.Add(e);
}
}
public MetadataTable Load(TablesHeap h, MetadataReader rdr, uint[] lens, TableType type)
{
MetadataTable ret = new MetadataTable(h, type);
Reader[] read = new Reader[ret.Columns.Length];
for (int i = 0; i < ret.Columns.Length; i++)
{
int k = i;
var retColTypeObj = ret.Columns[i].Type;
if (retColTypeObj is Type)
{
var retColType = retColTypeObj as Type;
//if (retColType.IsSubclassOf(typeof(Enum)))
if (retColType.IsEnum)
{
var underEnumType = Enum.GetUnderlyingType(retColType);
//read[i] = DicEnumReader[underEnumType];
if (underEnumType == typeof(byte))
{
read[i] = new Reader(ReadByteFlag);
}
else if (underEnumType == typeof(System.UInt16))
{
read[i] = new Reader(ReadUInt16Flag);
}
else if (underEnumType == typeof(System.UInt32))
{
read[i] = new Reader(ReadUInt32Flag);
}
//switch (Enum.GetUnderlyingType(retColType).FullName)
//{
// case "System.Byte":
// read[i] = new Reader(ReadByteFlag);
// break;
// case "System.UInt16":
// read[i] = new Reader(ReadUInt16Flag);
// break;
// case "System.UInt32":
// read[i] = new Reader(ReadUInt32Flag);
// break;
//}
}
else
{
//read[i] = DicReader[retColType];
if (retColType == typeof(byte))
{
read[i] = new Reader(ReadByte);
}
else if (retColType == typeof(System.UInt16))
{
read[i] = new Reader(ReadUInt16);
}
else if (retColType == typeof(System.UInt32))
{
read[i] = new Reader(ReadUInt32);
}
else if (retColType == typeof(NetPE.Core.Rva))
{
read[i] = new Reader(ReadRva);
}
else if (retColType == typeof(NetPE.Core.Metadata.BlobToken))
{
read[i] = new Reader(ReadBlobToken);
}
else if (retColType == typeof(NetPE.Core.Metadata.GUIDToken))
{
read[i] = new Reader(ReadGUIDToken);
}
else if (retColType == typeof(NetPE.Core.Metadata.StringToken))
{
read[i] = new Reader(ReadStringToken);
}
//switch ((ret.Columns[i].Type as Type).FullName)
//{
// case "System.Byte":
// read[i] = new Reader(ReadByte);
// break;
// case "System.UInt16":
// read[i] = new Reader(ReadUInt16);
// break;
// case "System.UInt32":
// read[i] = new Reader(ReadUInt32);
// break;
// case "NetPE.Core.Rva":
// read[i] = new Reader(ReadRva);
// break;
// case "NetPE.Core.Metadata.BlobToken":
// read[i] = new Reader(ReadBlobToken);
// break;
// case "NetPE.Core.Metadata.GUIDToken":
// read[i] = new Reader(ReadGUIDToken);
// break;
// case "NetPE.Core.Metadata.StringToken":
// read[i] = new Reader(ReadStringToken);
// break;
//}
}
}
else if (retColTypeObj is TableType)
{
read[i] = new Reader(ReadTableToken);
}
else if (retColTypeObj is CodedIndex)
{
read[i] = new Reader(ReadCodedToken);
}
}
List <Rva> rvas = new List <Rva>();
for (int i = 1; i <= lens[(int)ret.Type]; i++)
{
MetadataRow r = new MetadataRow(ret, false);
bool hasRva = ret.Type == TableType.MethodDef || ret.Type == TableType.FieldRVA;
int rvaIdx = 0;
Rva rva = 0;
for (int ii = 0; ii < read.Length; ii++)
{
if (hasRva && (ret.Columns[ii].Type is Type) && ((ret.Columns[ii].Type as Type) == typeof(NetPE.Core.Rva)))
{
rvaIdx = ii;
rva = (Rva)rdr.ReadUInt32();
}
else
{
r[ii] = read[ii](ii, ret, rdr, lens);
}
}
if (hasRva)
{
r[rvaIdx] = rva;
rvas.Add(rva);
}
r.Token = new MetadataToken((MetadataTokenType)ret.Type, (uint)i);
ret.Rows.Add(r);
}
ReadRvaData(ret, rdr, rvas, ret.Rows);
return(ret);
}
