Aracılığıyla paylaş

DisassemblyData

Tümleşik geliştirme ortamının (IDE) görüntülenmesi için tek bir ayrıştırma yönergesini açıklar.

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;
};

Members

dwFields
Hangi alanların doldurulduğunu belirten DISASSEMBLY_STREAM_FIELDS sabiti.

bstrAddress
Bir başlangıç noktasından uzaklık olarak adres (genellikle ilişkili işlevin başlangıcı).

bstrCodeBytes
Bu yönerge için kod baytları.

bstrOpcode
Bu komutun işlem kodu.

bstrOperands
Bu komutun işlenenleri.

bstrSymbol
Varsa, adresle ilişkili simge adı (genel simge, etiket vb.).

uCodeLocationId
Bu ayrıştırılmış satırın kod konumu tanımlayıcısı. Bir satırın kod bağlam adresi başka bir satırın kod bağlam adresinden büyükse, birincinin ayrıştırılmış kod konumu tanımlayıcısı da ikinci satırın kod konumu tanımlayıcısından büyük olur.

posBeg
Bir belgedeki ayrıştırma verilerinin başladığı konuma karşılık gelen TEXT_POSITION .

posEnd
Bir belgedeki ayrıştırma verilerinin sona erdiği konuma karşılık gelen TEXT_POSITION .

bstrDocumentUrl
Dosya adları olarak temsil edilebilen metin belgeleri için, bstrDocumentUrl alanı, biçimini file://file namekullanarak kaynağın bulunabileceği dosya adıyla doldurulur.

Dosya adları olarak temsil edilemeyen metin belgeleri için, bstrDocumentUrl belge için benzersiz bir tanımlayıcıdır ve hata ayıklama altyapısının GetDocument yöntemini uygulaması gerekir.

Bu alan sağlama toplamları hakkında ek bilgiler de içerebilir. Ayrıntılar için bkz. Açıklamalar.

dwByteOffset
Yönerge, kod satırının başından itibaren kaç bayt uzunluğundadır.

dwFlags
Hangi bayrakların etkin olduğunu belirten DISASSEMBLY_FLAGS sabiti.

Remarks

Her DisassemblyData yapı bir ayrıştırma yönergesini açıklar. Read yönteminden bu yapıların dizisi döndürülür.

TEXT_POSITION yapısı yalnızca metin tabanlı belgeler için kullanılır. Bu yönergenin kaynak kod aralığı, bir deyim veya satırdan oluşturulan ilk yönerge için doldurulur, örneğin, when dwByteOffset == 0.

Metinsel olmayan belgeler için koddan bir belge bağlamı alınabilir ve bstrDocumentUrl alan null değer olmalıdır. bstrDocumentUrl Alan, önceki bstrDocumentUrl dizi öğesindeki alanla DisassemblyData aynıysa, alanını null değer olarak ayarlayınbstrDocumentUrl.

dwFlags alanının işaret ettiği dizinin ardından, DF_DOCUMENT_CHECKSUM alanında bstrDocumentUrl bayrağı ayarlanmışsa ek sağlama toplamı bilgileri gelir. Özellikle, null dize sonlandırıcıdan sonra, sağlama toplamı algoritmasını tanımlayan bir GUID izler ve ardından sağlama toplamındaki bayt sayısını belirten 4 bayt değeri ve ardından sağlama toplamı baytları gelir. Visual C# içinde bu alanı kodlama ve kodunu çözme ile ilgili bu konudaki Örne bakın.

Example

Bayrak bstrDocumentUrl ayarlandığında, DF_DOCUMENT_CHECKSUM alanı dize dışında ek bilgiler içerebilir. Visual C++'da bu kodlanmış dizeyi oluşturma ve okuma işlemi oldukça kolaydır. Ancak, Visual C# dilinde bu başka bir konudur. Merak edenler için aşağıdaki örnekte Visual C# dilinde kodlanmış dize oluşturmanın bir yolu ve Visual C# dilinde kodlanmış dizenin kodunu çözmenin bir yolu gösterilmektedir.

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);
                }
            }
        }
    }
}

Ayrıca bakınız

  • Last updated on