DisassemblyData
Beschreibt eine Demontageanweisung für die integrierte Entwicklungsumgebung (Integrated Development Environment, IDE), die angezeigt werden soll.
Syntax
public struct DisassemblyData {
public uint dwFields;
public string bstrAddress;
public string bstrAddressOffset;
public string bstrCodeBytes;
public string bstrOpcode;
public string bstrOperands;
public string bstrSymbol;
public ulong uCodeLocationId;
public TEXT_POSITION posBeg;
public TEXT_POSITION posEnd;
public string bstrDocumentUrl;
public uint dwByteOffset;
public uint dwFlags;
};
Mitglieder
dwFields
Die DISASSEMBLY_STREAM_FIELDS Konstante, die angibt, welche Felder ausgefüllt sind.
bstrAddress
Die Adresse als Offset von einem Bestimmten Ausgangspunkt (in der Regel der Anfang der zugeordneten Funktion).
bstrCodeBytes
Die Codebytes für diese Anweisung.
bstrOpcode
Der Opcode für diese Anweisung.
bstrOperands
Die Operanden für diese Anweisung.
bstrSymbol
Der Symbolname (sofern vorhanden), der der Adresse zugeordnet ist (öffentliches Symbol, Beschriftung usw.).
uCodeLocationId
Der Codespeicherortbezeichner für diese zerlegte Zeile. Wenn die Codekontextadresse einer Zeile größer als die Codekontextadresse eines anderen ist, ist der zerlegte Codespeicherortbezeichner des ersten außerdem größer als der Codespeicherortbezeichner des zweiten.
posBeg
Die TEXT_POSITION , die der Position in einem Dokument entspricht, an der die Demontagedaten beginnen.
posEnd
Die TEXT_POSITION , die der Position in einem Dokument entspricht, an der die Zerlegungsdaten enden.
bstrDocumentUrl
Bei Textdokumenten, die als Dateinamen dargestellt werden können, wird das bstrDocumentUrl Feld mit dem Dateinamen ausgefüllt, in dem die Quelle gefunden werden kann, mithilfe des Formats file://file name.
Bei Textdokumenten, die nicht als Dateinamen dargestellt werden können, bstrDocumentUrl handelt es sich um einen eindeutigen Bezeichner für das Dokument, und das Debugmodul muss die GetDocument-Methode implementieren.
Dieses Feld kann auch zusätzliche Informationen zu Prüfsummen enthalten. Weitere Informationen finden Sie im Abschnitt Hinweise.
dwByteOffset
Die Anzahl der Bytes, die die Anweisung vom Anfang der Codezeile stammt.
dwFlags
Die DISASSEMBLY_FLAGS Konstante, die angibt, welche Flags aktiv sind.
Hinweise
Jede DisassemblyData Struktur beschreibt eine Anweisung zur Demontage. Ein Array dieser Strukturen wird von der Read-Methode zurückgegeben.
Die TEXT_POSITION Struktur wird nur für textbasierte Dokumente verwendet. Der Quellcodebereich für diese Anweisung wird nur für die erste Anweisung ausgefüllt, die aus einer Anweisung oder Zeile generiert wird, z. B. wenn dwByteOffset == 0.
Bei Dokumenten, die kein Text sind, kann ein Dokumentkontext aus dem Code abgerufen werden, und das bstrDocumentUrl Feld sollte ein NULL-Wert sein. Wenn das bstrDocumentUrl Feld mit dem bstrDocumentUrl Feld im vorherigen DisassemblyData Arrayelement identisch ist, legen Sie den bstrDocumentUrl Wert auf null fest.
Wenn das Feld die dwFlagsDF_DOCUMENT_CHECKSUM Kennzeichnung festgelegt hat, folgen zusätzliche Prüfsummeninformationen der Zeichenfolge, auf die das bstrDocumentUrl Feld verweist. Genauer gesagt folgt nach dem Nullzeichenfolgenendpunkt eine GUID, die den Prüfsummenalgorithmus identifiziert, gefolgt von einem 4-Byte-Wert, der die Anzahl der Bytes in der Prüfsumme angibt und die wiederum von den Prüfsummenbytes gefolgt wird. Weitere Informationen zum Codieren und Decodieren dieses Felds in Visual C# finden Sie im Beispiel in diesem Thema.
Beispiel
Das bstrDocumentUrl Feld kann andere Informationen als eine Zeichenfolge enthalten, wenn das DF_DOCUMENT_CHECKSUM Kennzeichen festgelegt ist. Der Prozess zum Erstellen und Lesen dieser codierten Zeichenfolge ist in Visual C++ einfach. In Visual C# ist dies jedoch eine andere Sache. Für diejenigen, die neugierig sind, zeigt das folgende Beispiel eine Möglichkeit zum Erstellen der codierten Zeichenfolge aus Visual C# und eine Möglichkeit zum Decodieren der codierten Zeichenfolge in Visual C#.
using System;
using System.Runtime.InteropServices;
namespace MyNamespace
{
class MyClass
{
string EncodeData(string documentString,
Guid checksumGuid,
byte[] checksumData)
{
string returnString = documentString;
if (checksumGuid == null || checksumData == null)
{
// Nothing more to do. Just return the string.
return returnString;
}
returnString += '\0'; // separating null value
// Add checksum GUID to string.
byte[] guidDataArray = checksumGuid.ToByteArray();
int guidDataLength = guidDataArray.Length;
IntPtr pBuffer = Marshal.AllocCoTaskMem(guidDataLength);
for (int i = 0; i < guidDataLength; i++)
{
Marshal.WriteByte(pBuffer, i, guidDataArray[i]);
}
// Copy guid data bytes to string as wide characters.
// Assumption: sizeof(char) == 2.
for (int i = 0; i < guidDataLength / sizeof(char); i++)
{
returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
}
// Add checksum count (a 32-bit value).
Int32 checksumCount = checksumData.Length;
Marshal.StructureToPtr(checksumCount, pBuffer, true);
for (int i = 0; i < sizeof(Int32) / sizeof(char); i++)
{
returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
}
// Add checksum data.
pBuffer = Marshal.AllocCoTaskMem(checksumCount);
for (int i = 0; i < checksumCount; i++)
{
Marshal.WriteByte(pBuffer, i, checksumData[i]);
}
for (int i = 0; i < checksumCount / sizeof(char); i++)
{
returnString += (char)Marshal.ReadInt16(pBuffer, i * sizeof(char));
}
Marshal.FreeCoTaskMem(pBuffer);
return returnString;
}
void DecodeData( string encodedString,
out string documentString,
out Guid checksumGuid,
out byte[] checksumData)
{
documentString = String.Empty;
checksumGuid = Guid.Empty;
checksumData = null;
IntPtr pBuffer = Marshal.StringToBSTR(encodedString);
if (null != pBuffer)
{
int bufferOffset = 0;
// Parse string out. String is assumed to be Unicode.
documentString = Marshal.PtrToStringUni(pBuffer);
bufferOffset += (documentString.Length + 1) * sizeof(char);
// Parse Guid out.
// Read guid bytes from buffer and store in temporary
// buffer that contains only the guid bytes. Then the
// Marshal.PtrToStructure() can work properly.
byte[] guidDataArray = checksumGuid.ToByteArray();
int guidDataLength = guidDataArray.Length;
IntPtr pGuidBuffer = Marshal.AllocCoTaskMem(guidDataLength);
for (int i = 0; i < guidDataLength; i++)
{
Marshal.WriteByte(pGuidBuffer, i,
Marshal.ReadByte(pBuffer, bufferOffset + i));
}
bufferOffset += guidDataLength;
checksumGuid = (Guid)Marshal.PtrToStructure(pGuidBuffer, typeof(Guid));
Marshal.FreeCoTaskMem(pGuidBuffer);
// Parse out the number of checksum data bytes (always 32-bit value).
int dataCount = Marshal.ReadInt32(pBuffer, bufferOffset);
bufferOffset += sizeof(Int32);
// Parse out the checksum data.
checksumData = new byte[dataCount];
for (int i = 0; i < dataCount; i++)
{
checksumData[i] = Marshal.ReadByte(pBuffer, bufferOffset + i);
}
}
}
}
}