DisassemblyData
Describe una instrucción de desensamblaje para que se muestre el entorno de desarrollo integrado (IDE).
Sintaxis
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;
};
Miembros
dwFields
Constante DISASSEMBLY_STREAM_FIELDS que especifica qué campos se rellenan.
bstrAddress
Dirección como desplazamiento desde algún punto de partida (normalmente el principio de la función asociada).
bstrCodeBytes
Bytes de código para esta instrucción.
bstrOpcode
Código de operación para esta instrucción.
bstrOperands
Operandos para esta instrucción.
bstrSymbol
El nombre del símbolo, si existe, asociado a la dirección (símbolo público, etiqueta, etc.).
uCodeLocationId
Identificador de ubicación de código para esta línea desensambblada. Si la dirección de contexto de código de una línea es mayor que la dirección de contexto de código de otra, el identificador de ubicación del código desensambblado del primero también será mayor que el identificador de ubicación del código del segundo.
posBeg
El TEXT_POSITION que corresponde a la posición de un documento donde comienzan los datos de desensamblar.
posEnd
El TEXT_POSITION que corresponde a la posición de un documento donde finalizan los datos de desensamblar.
bstrDocumentUrl
Para los documentos de texto que se pueden representar como nombres de archivo, el bstrDocumentUrl campo se rellena con el nombre de archivo donde se puede encontrar el origen, con el formato file://file name.
Para los documentos de texto que no se pueden representar como nombres de archivo, bstrDocumentUrl es un identificador único para el documento y el motor de depuración debe implementar el método GetDocument .
Este campo también puede contener información adicional sobre sumas de comprobación. Consulte Comentarios para obtener más detalles.
dwByteOffset
El número de bytes que la instrucción es desde el principio de la línea de código.
dwFlags
Constante DISASSEMBLY_FLAGS que especifica qué marcas están activas.
Comentarios
Cada DisassemblyData estructura describe una instrucción de desensamblaje. Se devuelve una matriz de estas estructuras desde el método Read .
La estructura TEXT_POSITION solo se usa para documentos basados en texto. El intervalo de código fuente de esta instrucción se rellena solo para la primera instrucción generada a partir de una instrucción o línea, por ejemplo, cuando dwByteOffset == 0.
Para los documentos que no son textuales, se puede obtener un contexto de documento del código y el bstrDocumentUrl campo debe ser un valor NULL. Si el bstrDocumentUrl campo es el mismo que el bstrDocumentUrl campo del elemento de matriz anterior DisassemblyData , establezca en bstrDocumentUrl un valor NULL.
Si el dwFlags campo tiene la DF_DOCUMENT_CHECKSUM marca establecida, la información adicional de suma de comprobación sigue la cadena a la que apunta el bstrDocumentUrl campo. En concreto, después del terminador de cadena NULL, sigue un GUID que identifica el algoritmo de suma de comprobación que, a su vez, va seguido de un valor de 4 bytes que indica el número de bytes de la suma de comprobación y, a su vez, va seguido de los bytes de suma de comprobación. Vea el ejemplo de este tema sobre cómo codificar y descodificar este campo en Visual C#.
Ejemplo
El bstrDocumentUrl campo puede contener información adicional distinta de una cadena si se establece la DF_DOCUMENT_CHECKSUM marca. El proceso de creación y lectura de esta cadena codificada es sencillo en Visual C++. Sin embargo, en Visual C#, es otra cuestión. Para aquellos que tienen curiosidad, en el ejemplo siguiente se muestra una manera de crear la cadena codificada desde Visual C# y una manera de descodificar la cadena codificada en 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);
}
}
}
}
}