public TablesStreamNode(HexDocument doc, TablesStream tblStream, IMetaData md)
: base((ulong)tblStream.StartOffset, (ulong)tblStream.MDTables[0].StartOffset - 1)
{
this.tablesStreamVM = new TablesStreamVM(this, doc, tblStream);
this.newChildren = new List <ITreeNodeData>();
foreach (var mdTable in tblStream.MDTables)
{
if (mdTable.Rows != 0)
{
this.newChildren.Add(new MetaDataTableNode(doc, mdTable, md));
}
}
}
public StorageHeaderVM(object owner, HexDocument doc, ulong startOffset)
: base(owner)
{
this.fFlagsVM = new ByteFlagsHexField(doc, Name, "fFlags", startOffset + 0);
this.fFlagsVM.Add(new BooleanHexBitField("ExtraData", 0));
this.padVM = new ByteHexField(doc, Name, "pad", startOffset + 1);
this.iStreamsVM = new UInt16HexField(doc, Name, "iStreams", startOffset + 2);
this.hexFields = new HexField[] {
fFlagsVM,
padVM,
iStreamsVM,
};
}
uint ReadFieldValue(HexDocument doc, ColumnInfo col)
{
ulong start = StartOffset + (ulong)col.Offset;
if (col.Size == 2)
{
return(doc.ReadUInt16(start));
}
else if (col.Size == 4)
{
return(doc.ReadUInt32(start));
}
throw new InvalidOperationException();
}
public UInt32HexField(HexDocument doc, string parentName, string name, ulong start, bool useDecimal = false)
: base(doc, parentName, name, start, 4)
{
var val = doc.ReadUInt32(start);
this.data = new UInt32VM(val, a => UpdateValue())
{
UseDecimal = useDecimal
};
if (useDecimal)
{
this.data.Value = val;
}
}
public StorageStreamNode(HexDocument doc, StreamHeader sh, int streamNumber, DotNetStream knownStream, IMetaData md)
: base((ulong)sh.StartOffset, (ulong)sh.EndOffset - 1)
{
this.StreamNumber = streamNumber;
this.StorageStreamType = GetStorageStreamType(knownStream);
this.storageStreamVM = new StorageStreamVM(this, doc, StartOffset, (int)(EndOffset - StartOffset + 1 - 8));
var tblStream = knownStream as TablesStream;
if (tblStream != null)
{
this.newChild = new TablesStreamNode(doc, tblStream, md);
}
}
public HexDocumentDataSaver(HexDocument doc, ulong start, ulong end, string filename)
{
this.doc = doc;
this.start = start;
this.end = end;
this.filename = filename;
ulong len = end - start + 1;
if (len == 0 || len + BUF_SIZE - 1 < len)
{
this.progressMaximum = (long)(0x8000000000000000UL / (BUF_SIZE / 2));
}
else
{
this.progressMaximum = (long)((len + BUF_SIZE - 1) / BUF_SIZE);
}
}
public ImageOptionalHeader32VM(object owner, HexDocument doc, ulong startOffset, ulong endOffset)
: base(owner, doc, startOffset, endOffset, 0x20, 0x58)
{
this.BaseOfDataVM = new UInt32HexField(doc, Name, "BaseOfData", startOffset + 0x18);
this.ImageBaseVM = new UInt32HexField(doc, Name, "ImageBase", startOffset + 0x1C);
this.SizeOfStackReserveVM = new UInt32HexField(doc, Name, "SizeOfStackReserve", startOffset + 0x48);
this.SizeOfStackCommitVM = new UInt32HexField(doc, Name, "SizeOfStackCommit", startOffset + 0x4C);
this.SizeOfHeapReserveVM = new UInt32HexField(doc, Name, "SizeOfHeapReserve", startOffset + 0x50);
this.SizeOfHeapCommitVM = new UInt32HexField(doc, Name, "SizeOfHeapCommit", startOffset + 0x54);
var list = new List <HexField> {
MagicVM,
MajorLinkerVersionVM,
MinorLinkerVersionVM,
SizeOfCodeVM,
SizeOfInitializedDataVM,
SizeOfUninitializedDataVM,
AddressOfEntryPointVM,
BaseOfCodeVM,
BaseOfDataVM,
ImageBaseVM,
SectionAlignmentVM,
FileAlignmentVM,
MajorOperatingSystemVersionVM,
MinorOperatingSystemVersionVM,
MajorImageVersionVM,
MinorImageVersionVM,
MajorSubsystemVersionVM,
MinorSubsystemVersionVM,
Win32VersionValueVM,
SizeOfImageVM,
SizeOfHeadersVM,
CheckSumVM,
SubsystemVM,
DllCharacteristicsVM,
SizeOfStackReserveVM,
SizeOfStackCommitVM,
SizeOfHeapReserveVM,
SizeOfHeapCommitVM,
LoaderFlagsVM,
NumberOfRvaAndSizesVM,
};
AddDataDirs(list, endOffset);
}
public ImageCor20HeaderVM(object owner, HexDocument doc, ulong startOffset)
: base(owner)
{
this.CbVM = new UInt32HexField(doc, Name, "cb", startOffset + 0);
this.MajorRuntimeVersionVM = new UInt16HexField(doc, Name, "MajorRuntimeVersion", startOffset + 4, true);
this.MinorRuntimeVersionVM = new UInt16HexField(doc, Name, "MinorRuntimeVersion", startOffset + 6, true);
this.MetaDataVM = new DataDirVM(doc, Name, "MetaData", startOffset + 8);
this.FlagsVM = new UInt32FlagsHexField(doc, Name, "Flags", startOffset + 0x10);
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_IL_Only, 0));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_32BitReqd, 1));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_ILLibrary, 2));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_StrongNameSigned, 3));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_NativeEntryPoint, 4));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_TrackDebugData, 16));
this.FlagsVM.Add(new BooleanHexBitField(dnSpy_AsmEditor_Resources.HexNode_Cor20Header_Flags_32BitPref, 17));
this.EntryPointTokenRVAVM = new UInt32HexField(doc, Name, "EntryPoint Token/RVA", startOffset + 0x14);
this.ResourcesVM = new DataDirVM(doc, Name, "Resources", startOffset + 0x18);
this.StrongNameSignatureVM = new DataDirVM(doc, Name, "StrongNameSignature", startOffset + 0x20);
this.CodeManagerTableVM = new DataDirVM(doc, Name, "CodeManagerTable", startOffset + 0x28);
this.VTableFixupsVM = new DataDirVM(doc, Name, "VTableFixups", startOffset + 0x30);
this.ExportAddressTableJumpsVM = new DataDirVM(doc, Name, "ExportAddressTableJumps", startOffset + 0x38);
this.ManagedNativeHeaderVM = new DataDirVM(doc, Name, "ManagedNativeHeader", startOffset + 0x40);
this.hexFields = new HexField[] {
CbVM,
MajorRuntimeVersionVM,
MinorRuntimeVersionVM,
MetaDataVM.RVAVM,
MetaDataVM.SizeVM,
FlagsVM,
EntryPointTokenRVAVM,
ResourcesVM.RVAVM,
ResourcesVM.SizeVM,
StrongNameSignatureVM.RVAVM,
StrongNameSignatureVM.SizeVM,
CodeManagerTableVM.RVAVM,
CodeManagerTableVM.SizeVM,
VTableFixupsVM.RVAVM,
VTableFixupsVM.SizeVM,
ExportAddressTableJumpsVM.RVAVM,
ExportAddressTableJumpsVM.SizeVM,
ManagedNativeHeaderVM.RVAVM,
ManagedNativeHeaderVM.SizeVM,
};
}
public ImageCor20HeaderVM(object owner, HexDocument doc, ulong startOffset)
: base(owner)
{
this.cbVM = new UInt32HexField(doc, Name, "cb", startOffset + 0);
this.majorRuntimeVersionVM = new UInt16HexField(doc, Name, "MajorRuntimeVersion", startOffset + 4, true);
this.minorRuntimeVersionVM = new UInt16HexField(doc, Name, "MinorRuntimeVersion", startOffset + 6, true);
this.metaDataVM = new DataDirVM(doc, Name, "MetaData", startOffset + 8);
this.flagsVM = new UInt32FlagsHexField(doc, Name, "Flags", startOffset + 0x10);
this.flagsVM.Add(new BooleanHexBitField("IL Only", 0));
this.flagsVM.Add(new BooleanHexBitField("32-Bit Required", 1));
this.flagsVM.Add(new BooleanHexBitField("IL Library", 2));
this.flagsVM.Add(new BooleanHexBitField("Strong Name Signed", 3));
this.flagsVM.Add(new BooleanHexBitField("Native EntryPoint", 4));
this.flagsVM.Add(new BooleanHexBitField("Track Debug Data", 16));
this.flagsVM.Add(new BooleanHexBitField("32-Bit Preferred", 17));
this.entryPointTokenRVAVM = new UInt32HexField(doc, Name, "EntryPoint Token/RVA", startOffset + 0x14);
this.resourcesVM = new DataDirVM(doc, Name, "Resources", startOffset + 0x18);
this.strongNameSignatureVM = new DataDirVM(doc, Name, "StrongNameSignature", startOffset + 0x20);
this.codeManagerTableVM = new DataDirVM(doc, Name, "CodeManagerTable", startOffset + 0x28);
this.vtableFixupsVM = new DataDirVM(doc, Name, "VTableFixups", startOffset + 0x30);
this.exportAddressTableJumpsVM = new DataDirVM(doc, Name, "ExportAddressTableJumps", startOffset + 0x38);
this.managedNativeHeaderVM = new DataDirVM(doc, Name, "ManagedNativeHeader", startOffset + 0x40);
this.hexFields = new HexField[] {
cbVM,
majorRuntimeVersionVM,
minorRuntimeVersionVM,
metaDataVM.RVAVM,
metaDataVM.SizeVM,
flagsVM,
entryPointTokenRVAVM,
resourcesVM.RVAVM,
resourcesVM.SizeVM,
strongNameSignatureVM.RVAVM,
strongNameSignatureVM.SizeVM,
codeManagerTableVM.RVAVM,
codeManagerTableVM.SizeVM,
vtableFixupsVM.RVAVM,
vtableFixupsVM.SizeVM,
exportAddressTableJumpsVM.RVAVM,
exportAddressTableJumpsVM.SizeVM,
managedNativeHeaderVM.RVAVM,
managedNativeHeaderVM.SizeVM,
};
}
public StorageSignatureVM(HexDocument doc, ulong startOffset, int stringLen)
{
this.lSignatureVM = new UInt32HexField(doc, Name, "lSignature", startOffset + 0);
this.iMajorVerVM = new UInt16HexField(doc, Name, "iMajorVer", startOffset + 4, true);
this.iMinorVerVM = new UInt16HexField(doc, Name, "iMinorVer", startOffset + 6, true);
this.iExtraDataVM = new UInt32HexField(doc, Name, "iExtraData", startOffset + 8);
this.iVersionStringVM = new UInt32HexField(doc, Name, "iVersionString", startOffset + 0x0C);
this.versionStringVM = new StringHexField(doc, Name, "VersionString", startOffset + 0x10, Encoding.UTF8, stringLen);
this.hexFields = new HexField[] {
lSignatureVM,
iMajorVerVM,
iMinorVerVM,
iExtraDataVM,
iVersionStringVM,
versionStringVM,
};
}
public HexBoxDocumentTabUIContext(HexDocument hexDocument, IMenuService menuService, IHexEditorSettings hexEditorSettings, IAppSettings appSettings, IHexBoxUndoService hexBoxUndoService)
{
this.hexDocument = hexDocument;
this.dnHexBox = new DnHexBox(menuService, hexEditorSettings);
this.dnHexBox.Document = this.hexDocument;
this.dnHexBox.InitializeStartEndOffsetToDocument();
this.scrollViewer = new ScrollViewer {
Content = this.dnHexBox,
CanContentScroll = true,
HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
Focusable = false,
};
this.appSettings = appSettings;
this.hexBoxUndoService = hexBoxUndoService;
appSettings.PropertyChanged += AppSettings_PropertyChanged;
UpdateHexBoxRenderer(appSettings.UseNewRenderer_HexEditor);
hexBoxUndoService.Initialize(this.dnHexBox);
}
public StorageSignatureVM(object owner, HexDocument doc, ulong startOffset, int stringLen)
: base(owner)
{
this.LSignatureVM = new UInt32HexField(doc, Name, "lSignature", startOffset + 0);
this.IMajorVerVM = new UInt16HexField(doc, Name, "iMajorVer", startOffset + 4, true);
this.IMinorVerVM = new UInt16HexField(doc, Name, "iMinorVer", startOffset + 6, true);
this.IExtraDataVM = new UInt32HexField(doc, Name, "iExtraData", startOffset + 8);
this.IVersionStringVM = new UInt32HexField(doc, Name, "iVersionString", startOffset + 0x0C);
this.VersionStringVM = new StringHexField(doc, Name, "VersionString", startOffset + 0x10, Encoding.UTF8, stringLen);
this.hexFields = new HexField[] {
LSignatureVM,
IMajorVerVM,
IMinorVerVM,
IExtraDataVM,
IVersionStringVM,
VersionStringVM,
};
}
void InitializeHexDocument()
{
cachedHexStream = null;
if (theDebugger.ProcessState == DebuggerProcessState.Terminated)
{
this.HexDocument = null;
}
else
{
var process = theDebugger.Debugger.Processes.FirstOrDefault();
Debug.Assert(process != null);
if (process == null)
{
this.HexDocument = null;
}
else
{
this.HexDocument = new HexDocument(cachedHexStream = new CachedHexStream(new ProcessHexStream(process.CorProcess.Handle)), string.Format("<MEMORY: pid {0}>", process.ProcessId));
}
}
}
public ImageFileHeaderVM(object owner, HexDocument doc, ulong startOffset)
: base(owner)
{
this.machineVM = new UInt16FlagsHexField(doc, Name, "Machine", startOffset + 0);
this.machineVM.Add(new IntegerHexBitField("Machine", 0, 16, MachineInfos));
this.numberOfSectionsVM = new UInt16HexField(doc, Name, "NumberOfSections", startOffset + 2);
this.timeDateStampVM = new UInt32HexField(doc, Name, "TimeDateStamp", startOffset + 4);
this.timeDateStampVM.DataFieldVM.PropertyChanged += (s, e) => OnPropertyChanged("TimeDateStampString");
this.pointerToSymbolTableVM = new UInt32HexField(doc, Name, "PointerToSymbolTable", startOffset + 8);
this.numberOfSymbolsVM = new UInt32HexField(doc, Name, "NumberOfSymbols", startOffset + 0x0C);
this.sizeOfOptionalHeaderVM = new UInt16HexField(doc, Name, "SizeOfOptionalHeader", startOffset + 0x10);
this.characteristicsVM = new UInt16FlagsHexField(doc, Name, "Characteristics", startOffset + 0x12);
this.characteristicsVM.Add(new BooleanHexBitField("Relocs Stripped", 0));
this.characteristicsVM.Add(new BooleanHexBitField("Executable Image", 1));
this.characteristicsVM.Add(new BooleanHexBitField("Line Nums Stripped", 2));
this.characteristicsVM.Add(new BooleanHexBitField("Local Syms Stripped", 3));
this.characteristicsVM.Add(new BooleanHexBitField("Aggressive WS Trim", 4));
this.characteristicsVM.Add(new BooleanHexBitField("Large Address Aware", 5));
this.characteristicsVM.Add(new BooleanHexBitField("Reserved 0040h", 6));
this.characteristicsVM.Add(new BooleanHexBitField("Bytes Reversed Lo", 7));
this.characteristicsVM.Add(new BooleanHexBitField("32-Bit Machine", 8));
this.characteristicsVM.Add(new BooleanHexBitField("Debug Stripped", 9));
this.characteristicsVM.Add(new BooleanHexBitField("Removable Run From Swap", 10));
this.characteristicsVM.Add(new BooleanHexBitField("Net Run From Swap", 11));
this.characteristicsVM.Add(new BooleanHexBitField("System", 12));
this.characteristicsVM.Add(new BooleanHexBitField("Dll", 13));
this.characteristicsVM.Add(new BooleanHexBitField("Up System Only", 14));
this.characteristicsVM.Add(new BooleanHexBitField("Bytes Reversed Hi", 15));
this.hexFields = new HexField[] {
machineVM,
numberOfSectionsVM,
timeDateStampVM,
pointerToSymbolTableVM,
numberOfSymbolsVM,
sizeOfOptionalHeaderVM,
characteristicsVM,
};
}
public UInt64HexField(HexDocument doc, string parentName, string name, ulong start, bool useDecimal = false)
: base(doc, parentName, name, start, 8)
{
this.data = new UInt64VM(doc.ReadUInt64(start), a => UpdateValue(), useDecimal);
}
public Int32HexField(HexDocument doc, string parentName, string name, ulong start, bool useDecimal = false)
: base(doc, parentName, name, start, 4)
{
this.data = new Int32VM(doc.ReadInt32(start), a => UpdateValue(), useDecimal);
}
public ByteHexField(HexDocument doc, string parentName, string name, ulong start, bool useDecimal = false)
: base(doc, parentName, name, start, 1)
{
this.data = new ByteVM((byte)doc.ReadByte(start), a => UpdateValue(), useDecimal);
}
public DataDirVM(HexDocument doc, string parentName, string name, ulong start)
{
this.name = name;
this.rvaVM = new UInt32HexField(doc, parentName, string.Format(dnSpy_AsmEditor_Resources.HexField_RelativeVirtualAddress, name), start);
this.sizeVM = new UInt32HexField(doc, parentName, string.Format(dnSpy_AsmEditor_Resources.HexField_Size, name), start + 4);
}
public TablesStreamVM(object owner, HexDocument doc, TablesStream tblStream)
: base(owner)
{
ulong startOffset = (ulong)tblStream.StartOffset;
this.m_ulReservedVM = new UInt32HexField(doc, Name, "m_ulReserved", startOffset + 0);
this.m_majorVM = new ByteHexField(doc, Name, "m_major", startOffset + 4, true);
this.m_minorVM = new ByteHexField(doc, Name, "m_minor", startOffset + 5, true);
this.m_heapsVM = new ByteFlagsHexField(doc, Name, "m_heaps", startOffset + 6);
this.m_heapsVM.Add(new BooleanHexBitField("BigStrings", 0));
this.m_heapsVM.Add(new BooleanHexBitField("BigGUID", 1));
this.m_heapsVM.Add(new BooleanHexBitField("BigBlob", 2));
this.m_heapsVM.Add(new BooleanHexBitField("Padding", 3));
this.m_heapsVM.Add(new BooleanHexBitField("Reserved", 4));
this.m_heapsVM.Add(new BooleanHexBitField("DeltaOnly", 5));
this.m_heapsVM.Add(new BooleanHexBitField("ExtraData", 6));
this.m_heapsVM.Add(new BooleanHexBitField("HasDelete", 7));
this.m_ridVM = new ByteHexField(doc, Name, "m_rid", startOffset + 7);
this.m_maskvalidVM = new UInt64FlagsHexField(doc, Name, "m_maskvalid", startOffset + 8);
AddTableFlags(this.m_maskvalidVM);
this.m_sortedVM = new UInt64FlagsHexField(doc, Name, "m_sorted", startOffset + 0x10);
AddTableFlags(this.m_sortedVM);
var list = new List <HexField> {
m_ulReservedVM,
m_majorVM,
m_minorVM,
m_heapsVM,
m_ridVM,
m_maskvalidVM,
m_sortedVM,
};
this.rowsVM = new UInt32HexField[64];
ulong valid = tblStream.ValidMask;
ulong offs = startOffset + 0x18;
for (int i = 0; i < this.rowsVM.Length; i++)
{
this.rowsVM[i] = new UInt32HexField(doc, Name, string.Format("rows[{0:X2}]", i), offs);
if ((valid & 1) != 0)
{
list.Add(this.rowsVM[i]);
offs += 4;
}
else
{
this.rowsVM[i].IsVisible = false;
}
valid >>= 1;
}
this.m_ulExtraVM = new UInt32HexField(doc, Name, "m_ulExtra", offs);
this.m_ulExtraVM.IsVisible = tblStream.HasExtraData;
if (tblStream.HasExtraData)
{
list.Add(this.m_ulExtraVM);
}
Debug.Assert(offs == (ulong)tblStream.MDTables[0].StartOffset);
this.hexFields = list.ToArray();
}
public ImageFileHeaderTreeNode(HexDocument doc, ImageFileHeader fileHeader)
: base((ulong)fileHeader.StartOffset, (ulong)fileHeader.EndOffset - 1)
{
this.imageFileHeaderVM = new ImageFileHeaderVM(this, doc, StartOffset);
}
public ImageSectionHeaderNode(HexDocument doc, ImageSectionHeader sectHdr, int sectionNumber)
: base((ulong)sectHdr.StartOffset, (ulong)sectHdr.EndOffset - 1)
{
this.SectionNumber = sectionNumber;
this.imageSectionHeaderVM = new ImageSectionHeaderVM(this, doc, StartOffset);
}
public UInt64FlagsHexField(HexDocument doc, string parentName, string name, ulong start)
: base(doc, parentName, name, start, 8)
{
this.data = new UInt64VM(doc.ReadUInt64(start), a => UpdateValue(), false);
}
public ByteFlagsHexField(HexDocument doc, string parentName, string name, ulong start)
: base(doc, parentName, name, start, 1)
{
this.data = new ByteVM((byte)doc.ReadByte(start), a => UpdateValue(), false);
}
public StringHexField(HexDocument doc, string parentName, string name, ulong start, Encoding encoding, int dataLen)
: base(doc, parentName, name, start, dataLen)
{
this.encoding = encoding;
this.data = new StringVM((string)ReadData(), a => UpdateValue());
}
protected FlagsHexField(HexDocument doc, string parentName, string name, ulong start, int size)
: base(doc, parentName, name, start, size)
{
this.bitFields = new Dictionary <int, HexBitField>();
}
public WeakDocumentListener(PETreeNode node, HexDocument doc)
{
this.nodeWeakRef = new WeakReference(node);
doc.OnDocumentModified += HexDocument_OnDocumentModified;
}
public Int16FlagsHexField(HexDocument doc, string parentName, string name, ulong start)
: base(doc, parentName, name, start, 2)
{
this.data = new Int16VM(doc.ReadInt16(start), a => UpdateValue(), false);
}
public StorageHeaderNode(HexDocument doc, MetaDataHeader mdHeader)
: base((ulong)mdHeader.StorageHeaderOffset, (ulong)mdHeader.StorageHeaderOffset + 4 - 1)
{
this.storageHeaderVM = new StorageHeaderVM(this, doc, StartOffset);
}
public void SetDocument(HexDocument doc)
{
this.HexBox.Document = doc;
UpdateHeader();
}
public StorageSignatureNode(HexDocument doc, MetaDataHeader mdHeader)
: base((ulong)mdHeader.StartOffset, (ulong)mdHeader.StorageHeaderOffset - 1)
{
this.storageSignatureVM = new StorageSignatureVM(this, doc, StartOffset, (int)(EndOffset - StartOffset + 1 - 0x10));
}
