windows-xp/Source/XPSP1/NT/base/win32/fusion/sxs/dumpers.cpp

#include "stdinc.h"
#include <windows.h>
#include "sxsp.h"
#include <stdio.h>
#include "FusionHandle.h"
#include "sxsapi.h"
#include <limits.h>
typedef const void * PCVOID;

/*
Declaration of dumpers are moved from the relatively public sxsp.h
to here to contain their use.

These functions should be preceded by FusionpDbgWouldPrintAtFilterLevel calls
and surrounded by __try/__except(EXCEPTION_EXECUTE_HANDLER)

These function can consume a lot of stack, and time, when their output
ultimately doesn't go anywhere, and they overflow the small commited stack
in csrss under stress.
*/

VOID
SxspDbgPrintInstallSourceInfo(
    ULONG Level,
    PSXS_INSTALL_SOURCE_INFO Info,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataTocEntry(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_ENTRY Entry,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataTocSections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Data,
    const GUID *ExtensionGuid,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataTocSection(
    ULONG Level,
    bool fFull,
    PVOID Section,
    SIZE_T Length,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataExtendedTocHeader(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataExtendedTocEntry(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Entry,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataExtendedTocSections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataExtendedTocEntrySections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Data,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextStringSection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Data,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextGuidSection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Data,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextBinarySection(
    ULONG Level,
    bool fFull,
    PVOID Data,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintAssemblyInformation(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintDllRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_DLL_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintWindowClassRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_WINDOW_CLASS_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintClrSurrogateTable(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_CLR_SURROGATE Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintComServerRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintComProgIdRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_PROGID_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintTypeLibraryRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_TYPE_LIBRARY_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintComInterfaceRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    );

VOID
SxspDbgPrintActivationContextDataAssemblyRoster(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxspDbgPrintActivationContextDataTocHeader(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    );

VOID
SxsppDbgPrintActivationContextData(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SActivation Context Data %p\n"
            "%S   Magic = 0x%08lx (%lu)\n"
            "%S   HeaderSize = %d (0x%lx)\n"
            "%S   FormatVersion = %d\n",
            PLP, Data,
            PLP, Data->Magic, Data->Magic,
            PLP, Data->HeaderSize, Data->HeaderSize,
            PLP, Data->FormatVersion);

        ::FusionpDbgPrintEx(
            Level,
            "%S   TotalSize = %d (0x%lx)\n"
            "%S   DefaultTocOffset = %d (0x%lx) (-> %p)\n"
            "%S   ExtendedTocOffset = %d (0x%lx) (-> %p)\n",
            PLP, Data->TotalSize, Data->TotalSize,
            PLP, Data->DefaultTocOffset, Data->DefaultTocOffset, (Data->DefaultTocOffset == 0) ? NULL : (PVOID) (((ULONG_PTR) Data) + Data->DefaultTocOffset),
            PLP, Data->ExtendedTocOffset, Data->ExtendedTocOffset, (Data->ExtendedTocOffset == 0) ? NULL : (PVOID) (((ULONG_PTR) Data) + Data->ExtendedTocOffset));

        ::FusionpDbgPrintEx(
            Level,
            "%S   AssemblyRosterOffset = %d (0x%lx) (-> %p)\n",
            PLP, Data->AssemblyRosterOffset, Data->AssemblyRosterOffset, (Data->AssemblyRosterOffset == 0) ? NULL : (PVOID) (((ULONG_PTR) Data) + Data->AssemblyRosterOffset));
    }
    else
    {
        // !fFull
        ::FusionpDbgPrintEx(
            Level,
            "%SActivation Context Data %p (brief output)\n",
            PLP, Data);
    }

    rbuffPLP.Win32Append(L"   ", 3);

    if (Data->AssemblyRosterOffset != 0)
        ::SxspDbgPrintActivationContextDataAssemblyRoster(
            Level,
            fFull,
            Data,
            (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER) (((ULONG_PTR) Data) + Data->AssemblyRosterOffset),
            rbuffPLP);

    if (Data->DefaultTocOffset != 0)
        ::SxspDbgPrintActivationContextDataTocHeader(
            Level,
            fFull,
            Data,
            (PCACTIVATION_CONTEXT_DATA_TOC_HEADER) (((ULONG_PTR) Data) + Data->DefaultTocOffset),
            rbuffPLP);

    if (Data->ExtendedTocOffset != 0)
        ::SxspDbgPrintActivationContextDataExtendedTocHeader(
            Level,
            fFull,
            Data,
            (PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER) (((ULONG_PTR) Data) + Data->ExtendedTocOffset),
            rbuffPLP);

    // That's it for the header information.  Now start dumping the sections...
    if (Data->DefaultTocOffset != 0)
        ::SxspDbgPrintActivationContextDataTocSections(
            Level,
            fFull,
            Data,
            (PCACTIVATION_CONTEXT_DATA_TOC_HEADER) (((ULONG_PTR) Data) + Data->DefaultTocOffset),
            NULL,
            rbuffPLP);

    if (Data->ExtendedTocOffset != 0)
        ::SxspDbgPrintActivationContextDataExtendedTocSections(
            Level,
            fFull,
            Data,
            (PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER) (((ULONG_PTR) Data) + Data->ExtendedTocOffset),
            rbuffPLP);
}

VOID
SxspDbgPrintActivationContextData(
    ULONG Level,
    PCACTIVATION_CONTEXT_DATA Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    __try
    {
        if (::FusionpDbgWouldPrintAtFilterLevel(Level))
        {
            ::SxsppDbgPrintActivationContextData(Level, ::FusionpDbgWouldPrintAtFilterLevel(FUSION_DBG_LEVEL_FULLACTCTX), Data, rbuffPLP);
        }
    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Just eat it, we are seeing failures now in DbgPrint even
        with relatively shallow callstacks
        */
    }
}

VOID
SxspDbgPrintActivationContextDataAssemblyRoster(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    ULONG i;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY Entry;
    CSmallStringBuffer buffFlags;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION AssemblyInformation = NULL;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgAssemblyRosterEntryFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY_INVALID, "Invalid")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY_ROOT, "Root")
    };

    PCWSTR PLP = rbuffPLP;

    if (fFull)
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER %p\n"
            "%S   HeaderSize = %lu (0x%lx)\n"
            "%S   EntryCount = %lu (0x%lx)\n"
            "%S   FirstEntryOffset = %ld (0x%lx)\n",
            PLP, Data,
            PLP, Data->HeaderSize, Data->HeaderSize,
            PLP, Data->EntryCount, Data->EntryCount,
            PLP, Data->FirstEntryOffset, Data->FirstEntryOffset);
    else
        ::FusionpDbgPrintEx(
            Level,
            "%SAssembly Roster (%lu assemblies)\n"
            "%SIndex | Assembly Name (Flags)\n",
            PLP, Data->EntryCount - 1,
            PLP);

    for (i=0; i<Data->EntryCount; i++)
    {
        Entry = ((PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY) (((ULONG_PTR) Base) + Data->FirstEntryOffset)) + i;

        UNICODE_STRING s;

        if (Entry->AssemblyNameOffset != 0)
        {
            s.Length = (USHORT) Entry->AssemblyNameLength;
            s.MaximumLength = s.Length;
            s.Buffer = (PWSTR) (((ULONG_PTR) Base) + Entry->AssemblyNameOffset);
        }
        else
        {
            s.Length = 0;
            s.MaximumLength = 0;
            s.Buffer = NULL;
        }

        ::FusionpFormatFlags(Entry->Flags, fFull, NUMBER_OF(s_rgAssemblyRosterEntryFlags), s_rgAssemblyRosterEntryFlags, buffFlags);

        if (Entry->AssemblyInformationOffset != NULL)
            AssemblyInformation = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION) (((ULONG_PTR) Base) + Entry->AssemblyInformationOffset);
        else
            AssemblyInformation = NULL;

        if (fFull)
        {
            ::FusionpDbgPrintEx(
                Level,
                "%S   ACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY %p [#%d]\n"
                "%S      Flags = 0x%08lx (%S)\n"
                "%S      PseudoKey = %lu\n",
                PLP, Entry, i,
                PLP, Entry->Flags, static_cast<PCWSTR>(buffFlags),
                PLP, Entry->PseudoKey);

            ::FusionpDbgPrintEx(
                Level,
                "%S      AssemblyNameOffset = %lu (0x%lx) \"%wZ\"\n"
                "%S      AssemblyNameLength = %lu (0x%lx) \n"
                "%S      AssemblyInformationOffset = %lu (0x%lx) (-> %p)\n"
                "%S      AssemblyInformationLength = %lu (0x%lx)\n",
                PLP, Entry->AssemblyNameOffset, Entry->AssemblyNameOffset, &s,
                PLP, Entry->AssemblyNameLength, Entry->AssemblyNameLength,
                PLP, Entry->AssemblyInformationOffset, Entry->AssemblyInformationOffset, AssemblyInformation,
                PLP, Entry->AssemblyInformationLength, Entry->AssemblyInformationLength);
        }
        else
        {
            if (i != 0)
                ::FusionpDbgPrintEx(
                    Level,
                    "%S%5lu | %wZ (%S)\n",
                    PLP, i, &s, static_cast<PCWSTR>(buffFlags));
        }
    }
}

VOID
SxspDbgPrintActivationContextDataTocHeader(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffFlags;
    ULONG i;
    PCACTIVATION_CONTEXT_DATA_TOC_ENTRY FirstEntry = NULL;

    if (PLP == NULL)
        PLP = L"";

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_TOC_HEADER_DENSE, "Dense")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_TOC_HEADER_INORDER, "Inorder")
    };

    ::FusionpFormatFlags(Data->Flags, fFull, NUMBER_OF(s_rgFlags), s_rgFlags, buffFlags);

    if (Data->FirstEntryOffset != 0)
        FirstEntry = (PCACTIVATION_CONTEXT_DATA_TOC_ENTRY) (((ULONG_PTR) Base) + Data->FirstEntryOffset);

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_TOC_HEADER %p\n"
            "%S   HeaderSize = %d (0x%lx)\n"
            "%S   EntryCount = %d\n"
            "%S   FirstEntryOffset = %d (0x%lx) (-> %p)\n"
            "%S   Flags = 0x%08lx (%S)\n",
            PLP, Data,
            PLP, Data->HeaderSize, Data->HeaderSize,
            PLP, Data->EntryCount,
            PLP, Data->FirstEntryOffset, Data->FirstEntryOffset, FirstEntry,
            PLP, Data->Flags, static_cast<PCWSTR>(buffFlags));
    }

    if (FirstEntry != NULL)
    {
        SIZE_T cchSave = rbuffPLP.Cch();

        // Abuse the buffFlags buffer for the new per-line prefix.
        rbuffPLP.Win32Append(L"   ", 3);

        for (i=0; i<Data->EntryCount; i++)
            ::SxspDbgPrintActivationContextDataTocEntry(Level, fFull, Base, &FirstEntry[i], rbuffPLP);

        rbuffPLP.Left(cchSave);
        PLP = rbuffPLP;
    }

}

VOID
SxspDbgPrintActivationContextDataTocSections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Data,
    const GUID *ExtensionGuid,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    SIZE_T cchPLP = rbuffPLP.Cch();

    if (Data->FirstEntryOffset != 0)
    {
        PCACTIVATION_CONTEXT_DATA_TOC_ENTRY Entries = (PCACTIVATION_CONTEXT_DATA_TOC_ENTRY) (((ULONG_PTR) Base) + Data->FirstEntryOffset);
        ULONG i;

        for (i=0; i<Data->EntryCount; i++)
        {
            if (Entries[i].Offset != 0)
            {
                PVOID Section = (PVOID) (((ULONG_PTR) Base) + Entries[i].Offset);
                CSmallStringBuffer buffSectionId;
                PCSTR pszSectionName = "<untranslatable>";

                if (ExtensionGuid != NULL)
                {
                    WCHAR rgchBuff[sizeof(LONG)*CHAR_BIT];

                    ::SxspFormatGUID(*ExtensionGuid, buffSectionId);
                    buffSectionId.Win32Append(L".", 1);
                    swprintf(rgchBuff, L"%u", Entries[i].Id);
                    buffSectionId.Win32Append(rgchBuff, ::wcslen(rgchBuff));
                }
                else
                {
                    WCHAR rgchBuff[255];

#define MAP_ENTRY(_x, _y) case _x: if (fFull) pszSectionName = #_x; else pszSectionName = _y; break;

                    switch (Entries[i].Id)
                    {
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, "Assembly Information")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "DLL Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "Window Class Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION, "COM Server Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION, "COM Interface Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION, "COM Type Library Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION, "COM ProgId Redirection")
                    MAP_ENTRY(ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE, "Win32 Global Object Name Redirection")
                    }

                    if (pszSectionName != NULL)
                        swprintf(rgchBuff, L"%u (%S)", Entries[i].Id, pszSectionName);
                    else
                        swprintf(rgchBuff, L"%u", Entries[i].Id);

                    buffSectionId.Win32Append(rgchBuff, ::wcslen(rgchBuff));
                }

#if 0 // redundant at least in non-full prints
                if (fFull)
                    ::FusionpDbgPrintEx(
                        Level,
                        "%SSection Id %S at %p\n",
                        PLP, static_cast<PCWSTR>(buffSectionId), Section);
                else
                    ::FusionpDbgPrintEx(
                        Level,
                        "%S%s Data\n",
                        PLP, pszSectionName);
#endif //

                ::SxspDbgPrintActivationContextDataTocSection(
                    Level,
                    fFull,
                    Section,
                    Entries[i].Length,
                    ExtensionGuid,
                    Entries[i].Id,
                    pszSectionName,
                    rbuffPLP);
            }
        }
    }
}

VOID
SxspDbgPrintActivationContextDataTocSection(
    ULONG Level,
    bool fFull,
    PVOID Section,
    SIZE_T Length,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    )
{
    if (Length > sizeof(ULONG))
    {
        switch (*(ULONG *) Section)
        {
        case ACTIVATION_CONTEXT_STRING_SECTION_MAGIC:
            ::SxspDbgPrintActivationContextStringSection(
                Level,
                fFull,
                (PCACTIVATION_CONTEXT_STRING_SECTION_HEADER) Section,
                ExtensionGuid,
                SectionId,
                SectionName,
                rbuffPLP);
            break;
        case ACTIVATION_CONTEXT_GUID_SECTION_MAGIC:
            ::SxspDbgPrintActivationContextGuidSection(
                Level,
                fFull,
                (PCACTIVATION_CONTEXT_GUID_SECTION_HEADER) Section,
                ExtensionGuid,
                SectionId,
                SectionName,
                rbuffPLP);
            break;
        default:
            break;
        }
    }
    else if ( SectionId != 0 )
    {
        ::SxspDbgPrintActivationContextBinarySection(
            Level,
            fFull,
            Section,
            Length,
            rbuffPLP);
    }
}

const STRING *
SxspDbgSectionIdToNtString(
    ULONG Id
    )
{
    switch (Id)
    {
#define ENTRY(id, s) id : { const static STRING t = RTL_CONSTANT_STRING(s); return &t; }
    ENTRY(default, "<No name associated with id>");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION, "Assembly Information");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION, "Dll Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION, "Window Class Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION, "COM Server Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION, "COM Interface Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION, "COM Type Library Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION, "COM ProgId Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_GLOBAL_OBJECT_RENAME_TABLE, "Win32 Global Object Name Redirection");
    ENTRY(case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES, "NDP Surrogate Type Table");
#undef ENTRY
    }
}

PCSTR
SxspDbgSectionIdToString(
    ULONG Id
    )
{
    return SxspDbgSectionIdToNtString(Id)->Buffer;
}

VOID
SxspDbgPrintActivationContextDataTocEntry(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_TOC_ENTRY Entry,
    CBaseStringBuffer &rbuffPLP
    )
{
    PVOID SectionData = NULL;
    PCSTR pszFormat = "<untranslated format>";
    PCWSTR PLP = rbuffPLP;

    if (!fFull)
        return;

    if (PLP == NULL)
        PLP = L"";

    if (Entry->Offset != 0)
        SectionData = (PVOID) (((ULONG_PTR) Base) + Entry->Offset);

#define MAP_FORMAT(_x, _sn) \
case _x: \
    if (fFull) \
        pszFormat = #_x; \
    else \
        pszFormat = _sn; \
    break;

    switch (Entry->Format)
    {
    default: break;
    MAP_FORMAT(ACTIVATION_CONTEXT_SECTION_FORMAT_UNKNOWN, "user defined");
    MAP_FORMAT(ACTIVATION_CONTEXT_SECTION_FORMAT_STRING_TABLE, "string table");
    MAP_FORMAT(ACTIVATION_CONTEXT_SECTION_FORMAT_GUID_TABLE, "guid table");
    }
#undef MAP_FORMAT

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_TOC_ENTRY %p\n"
            "%S   Id = %Z (%u)\n"
            "%S   Offset = %lu (0x%lx) (-> %p)\n"
            "%S   Length = %lu (0x%lx)\n"
            "%S   Format = %lu (%s)\n",
            PLP, Entry,
            PLP, SxspDbgSectionIdToNtString(Entry->Id), Entry->Id,
            PLP, Entry->Offset, Entry->Offset, SectionData,
            PLP, Entry->Length, Entry->Length,
            PLP, Entry->Format, pszFormat);
    }
    else
    {
        ::FusionpDbgPrintEx(
            Level,
            "%S%7lu | %Z (%s)\n",
            PLP, Entry->Id, SxspDbgSectionIdToNtString(Entry->Id), pszFormat);
    }
}

VOID
SxspDbgPrintActivationContextDataExtendedTocHeader(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffNewPrefix;
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Entry = NULL;
    ULONG i;

    if (PLP == NULL)
        PLP = L"";

    if (Data->FirstEntryOffset != NULL)
    {
        buffNewPrefix.Win32Assign(PLP, ::wcslen(PLP));
        buffNewPrefix.Win32Append(L"   ", 3);
        Entry = (PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY) (((ULONG_PTR) Base) + Data->FirstEntryOffset);
    }

    ::FusionpDbgPrintEx(
        Level,
        "%SACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER %p\n"
        "%S   HeaderSize = %d\n"
        "%S   EntryCount = %d\n"
        "%S   FirstEntryOffset = %d (->%p)\n"
        "%S   Flags = 0x%08lx\n",
        PLP, Data,
        PLP, Data->HeaderSize,
        PLP, Data->EntryCount,
        PLP, Data->FirstEntryOffset, Entry,
        PLP, Data->Flags);


    if (Entry != NULL)
    {
        for (i=0; i<Data->EntryCount; i++)
            ::SxspDbgPrintActivationContextDataExtendedTocEntry(
                Level,
                fFull,
                Base,
                &Entry[i],
                buffNewPrefix);
    }
}

VOID
SxspDbgPrintActivationContextDataExtendedTocEntry(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Entry,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffNewPrefix;
    CSmallStringBuffer buffFormattedGUID;
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Toc = NULL;

    if (PLP == NULL)
        PLP = L"";

    if (Entry->TocOffset != 0)
    {
        buffNewPrefix.Win32Assign(PLP, ::wcslen(PLP));
        buffNewPrefix.Win32Append(L"   ", 3);
        Toc = (PCACTIVATION_CONTEXT_DATA_TOC_HEADER) (((ULONG_PTR) Base) + Entry->TocOffset);
    }

    ::SxspFormatGUID(Entry->ExtensionGuid, buffFormattedGUID);

    ::FusionpDbgPrintEx(
        Level,
        "%SACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY %p\n"
        "%S   ExtensionGuid = %S\n"
        "%S   TocOffset = %d (-> %p)\n"
        "%S   Length = %d\n",
        PLP, Entry,
        PLP, static_cast<PCWSTR>(buffFormattedGUID),
        PLP, Entry->Length);

    if (Toc != NULL)
        ::SxspDbgPrintActivationContextDataTocHeader(Level, fFull, Base, Toc, buffNewPrefix);
}

VOID
SxspDbgPrintActivationContextDataExtendedTocSections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_HEADER Data,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffNewPrefix;
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Entry = NULL;
    ULONG i;

    if (PLP == NULL)
        PLP = L"";

    if (Data->FirstEntryOffset != NULL)
    {
        buffNewPrefix.Win32Assign(PLP, ::wcslen(PLP));
        buffNewPrefix.Win32Append(L"   ", 3);
        Entry = (PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY) (((ULONG_PTR) Base) + Data->FirstEntryOffset);
    }

    if (Entry != NULL)
    {
        for (i=0; i<Data->EntryCount; i++)
            ::SxspDbgPrintActivationContextDataExtendedTocEntrySections(
                Level,
                fFull,
                Base,
                &Entry[i],
                buffNewPrefix);
    }
}

VOID
SxspDbgPrintActivationContextDataExtendedTocEntrySections(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_DATA Base,
    PCACTIVATION_CONTEXT_DATA_EXTENDED_TOC_ENTRY Entry,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffNewPrefix;
    PCACTIVATION_CONTEXT_DATA_TOC_HEADER Toc = NULL;

    if (PLP == NULL)
        PLP = L"";

    if (Entry->TocOffset != 0)
    {
        buffNewPrefix.Win32Assign(PLP, ::wcslen(PLP));
        buffNewPrefix.Win32Append(L"   ", 3);
        Toc = (PCACTIVATION_CONTEXT_DATA_TOC_HEADER) (((ULONG_PTR) Base) + Entry->TocOffset);
    }

    if (Toc != NULL)
    {
        CSmallStringBuffer buffFormattedGUID;

        ::SxspFormatGUID(Entry->ExtensionGuid, buffFormattedGUID);
        ::FusionpDbgPrintEx(
            Level,
            "%SSections for extension GUID %S (Extended TOC entry %p)\n",
            PLP, static_cast<PCWSTR>(buffFormattedGUID), Entry);

        ::SxspDbgPrintActivationContextDataTocSections(Level, fFull, Base, Toc, &Entry->ExtensionGuid, buffNewPrefix);
    }
}

VOID
SxspDbgPrintActivationContextBinarySection(
    ULONG Level,
    bool fFull,
    PVOID Data,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    if (PLP == NULL)
        PLP = L"";

    ::FusionpDbgPrintEx(
        Level,
        "%SBinary section %p (%d bytes)\n",
        PLP, Data, Length);

    if (Length != 0)
    {
        CSmallStringBuffer buffNewPrefix;

        buffNewPrefix.Win32Assign(PLP, ::wcslen(PLP));
        buffNewPrefix.Win32Append(L"   ", 3);
        ::FusionpDbgPrintBlob(Level, Data, Length, buffNewPrefix);
    }
}

VOID
SxspDbgPrintActivationContextStringSection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Data,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    SIZE_T cchPLP = rbuffPLP.Cch();
    CSmallStringBuffer buffBriefOutput;
    CSmallStringBuffer buffFlags;
    SIZE_T cchBriefOutputKey = 3;

    PCACTIVATION_CONTEXT_STRING_SECTION_ENTRY ElementList = NULL;
    PCACTIVATION_CONTEXT_STRING_SECTION_HASH_TABLE SearchStructure = NULL;
    PVOID UserData = NULL;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgStringSectionFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_STRING_SECTION_CASE_INSENSITIVE, "Case Insensitive")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_STRING_SECTION_ENTRIES_IN_PSEUDOKEY_ORDER, "In PseudoKey Order")
    };

    if (PLP == NULL)
        PLP = L"";

    if (Data->ElementListOffset != 0)
        ElementList = (PCACTIVATION_CONTEXT_STRING_SECTION_ENTRY) (((ULONG_PTR) Data) + Data->ElementListOffset);

    if (Data->SearchStructureOffset != 0)
        SearchStructure = (PCACTIVATION_CONTEXT_STRING_SECTION_HASH_TABLE) (((ULONG_PTR) Data) + Data->SearchStructureOffset);

    if (Data->UserDataOffset != 0)
        UserData = (PVOID) (((ULONG_PTR) Data) + Data->UserDataOffset);

    ::FusionpFormatFlags(Data->Flags, fFull, NUMBER_OF(s_rgStringSectionFlags), s_rgStringSectionFlags, buffFlags);

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_STRING_SECTION_HEADER %p\n"
            "%S   Magic = 0x%08lx\n"
            "%S   HeaderSize = %lu (0x%lx)\n"
            "%S   FormatVersion = %lu\n"
            "%S   DataFormatVersion = %u\n"
            "%S   Flags = 0x%08lx (%S)\n",
            PLP, Data,
            PLP, Data->Magic,
            PLP, Data->HeaderSize, Data->HeaderSize,
            PLP, Data->FormatVersion,
            PLP, Data->DataFormatVersion,
            PLP, Data->Flags, static_cast<PCWSTR>(buffFlags));

        ::FusionpDbgPrintEx(
            Level,
            "%S   ElementCount = %lu\n"
            "%S   ElementListOffset = %lu (0x%lx) (-> %p)\n"
            "%S   HashAlgorithm = %lu\n"
            "%S   SearchStructureOffset = %lu (0x%lx) (-> %p)\n"
            "%S   UserDataOffset = %lu (0x%lx) (-> %p)\n"
            "%S   UserDataSize = %lu (0x%lx)\n",
            PLP, Data->ElementCount,
            PLP, Data->ElementListOffset, Data->ElementListOffset, ElementList,
            PLP, Data->HashAlgorithm,
            PLP, Data->SearchStructureOffset, Data->SearchStructureOffset, SearchStructure,
            PLP, Data->UserDataOffset, Data->UserDataOffset, UserData,
            PLP, Data->UserDataSize, Data->UserDataSize);

        if (UserData != NULL)
        {
            ::FusionpDbgPrintEx(
                Level,
                "%S   User data at %p (%d bytes)\n",
                PLP, UserData, Data->UserDataSize);

            rbuffPLP.Win32Append(L"   ", 3);
            FusionpDbgPrintBlob(Level, UserData, Data->UserDataSize, rbuffPLP);
            rbuffPLP.Left(cchPLP);
            PLP = rbuffPLP;
        }
    }
    else
    {
        // let's figure out the brief output key size
        cchBriefOutputKey = 3;

        if (ElementList != NULL)
        {
            ULONG i;

            for (i=0; i<Data->ElementCount; i++)
            {
                SIZE_T cch = ElementList[i].KeyLength / sizeof(WCHAR);

                if (cch > cchBriefOutputKey)
                    cchBriefOutputKey = cch;
            }
        }

        if (cchBriefOutputKey > 64)
            cchBriefOutputKey = 64;

        // Abuse the brief output buffer temporarily...
        buffBriefOutput.Win32Assign(L"Key................................................................", // 64 dots
            cchBriefOutputKey);

        ::FusionpDbgPrintEx(
            Level,
            "%S%s string section (%lu entr%s; Flags: %S)\n"
            "%S   %S | Value\n",
            PLP, SectionName, Data->ElementCount, Data->ElementCount == 1 ? "y" : "ies", static_cast<PCWSTR>(buffFlags),
            PLP, static_cast<PCWSTR>(buffBriefOutput));
    }

    if (fFull && (SearchStructure != NULL))
    {
        PCACTIVATION_CONTEXT_STRING_SECTION_HASH_BUCKET BucketTable = NULL;

        if (SearchStructure->BucketTableOffset != 0)
            BucketTable = (PCACTIVATION_CONTEXT_STRING_SECTION_HASH_BUCKET) (((ULONG_PTR) Data) + SearchStructure->BucketTableOffset);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ACTIVATION_CONTEXT_STRING_SECTION_HASH_TABLE %p\n"
            "%S      BucketTableEntryCount = %u\n"
            "%S      BucketTableOffset = %d (-> %p)\n",
            PLP, SearchStructure,
            PLP, SearchStructure->BucketTableEntryCount,
            PLP, SearchStructure->BucketTableOffset, BucketTable);

        if (BucketTable != NULL)
        {
            ULONG i;

            for (i=0; i<SearchStructure->BucketTableEntryCount; i++)
            {
                PLONG Entries = NULL;

                if (BucketTable[i].ChainOffset != 0)
                    Entries = (PLONG) (((ULONG_PTR) Data) + BucketTable[i].ChainOffset);

                ::FusionpDbgPrintEx(
                    Level,
                    "%S      ACTIVATION_CONTEXT_STRING_SECTION_HASH_BUCKET %p\n"
                    "%S         ChainCount = %u\n"
                    "%S         ChainOffset = %d (-> %p)\n",
                    PLP, &BucketTable[i],
                    PLP, BucketTable[i].ChainCount,
                    PLP, BucketTable[i].ChainOffset, Entries);

                if (Entries != NULL)
                {
                    ULONG j;

                    for (j=0; j<BucketTable[i].ChainCount; j++)
                    {
                        PVOID Entry = NULL;

                        if (Entries[j] != 0)
                            Entry = (PVOID) (((ULONG_PTR) Data) + Entries[j]);

                        ::FusionpDbgPrintEx(
                            Level,
                            "%S         Chain[%d] = %d (-> %p)\n",
                            PLP, j, Entries[j], Entry);
                    }
                }
            }
        }
    }

    if (ElementList != NULL)
    {
        ULONG i;

        for (i=0; i<Data->ElementCount; i++)
        {
            UNICODE_STRING s;
            PVOID EntryData = NULL;

            s.Length = static_cast<USHORT>(ElementList[i].KeyLength);
            s.MaximumLength = s.Length;
            s.Buffer = (PWSTR) (((ULONG_PTR) Data) + ElementList[i].KeyOffset);

            if (ElementList[i].Offset != 0)
                EntryData = (PVOID) (((ULONG_PTR) Data) + ElementList[i].Offset);

            if (fFull)
            {
                ::FusionpDbgPrintEx(
                    Level,
                    "%S   ACTIVATION_CONTEXT_STRING_SECTION_ENTRY #%d - %p\n"
                    "%S      AssemblyRosterIndex = %u\n"
                    "%S      PseudoKey = %u\n",
                    PLP, i, &ElementList[i],
                    PLP, ElementList[i].AssemblyRosterIndex,
                    PLP, ElementList[i].PseudoKey);

                ::FusionpDbgPrintEx(
                    Level,
                    "%S      String = \"%wZ\"\n"
                    "%S      Offset = %d (-> %p)\n"
                    "%S      Length = %u\n",
                    PLP, &s,
                    PLP, ElementList[i].Offset, EntryData,
                    PLP, ElementList[i].Length);
            }
            else
            {
                // Abuse the flags buffer so we can truncate the name as necessary...
                SIZE_T cchKey = s.Length / sizeof(WCHAR);
                PCWSTR pszKey = s.Buffer;

                if (cchKey > cchBriefOutputKey)
                {
                    pszKey += (cchKey - cchBriefOutputKey);
                    cchKey = cchBriefOutputKey;
                }

                buffFlags.Win32AssignFill(L' ', (cchBriefOutputKey - cchKey));
                buffFlags.Win32Append(pszKey, cchKey);

                buffBriefOutput.Win32ResizeBuffer(cchPLP + 3 + cchBriefOutputKey + 4, eDoNotPreserveBufferContents);

                buffBriefOutput.Win32Format(
                    L"%s   %s | ",
                    PLP, static_cast<PCWSTR>(buffFlags));
            }

            if (EntryData != NULL)
            {

                if (ExtensionGuid == NULL)
                {
                    rbuffPLP.Win32Append(L"      ", 6);

                    switch (SectionId)
                    {
                    default:
                        if (fFull)
                            ::FusionpDbgPrintBlob(Level, EntryData, ElementList[i].Length, rbuffPLP);
                        else
                            buffBriefOutput.Win32Append(
                                L"<untranslatable value>",
                                22);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_ASSEMBLY_INFORMATION:
                        ::SxspDbgPrintAssemblyInformation(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION:
                        ::SxspDbgPrintDllRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_DLL_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION:
                        ::SxspDbgPrintWindowClassRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_WINDOW_CLASS_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION:
                        ::SxspDbgPrintComProgIdRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_COM_PROGID_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;
                    }

                    rbuffPLP.Left(cchPLP);
                    PLP = rbuffPLP;
                }
            }

            if (!fFull)
                ::FusionpDbgPrintEx(Level, "%S\n", static_cast<PCWSTR>(buffBriefOutput));
        }
    }
}

VOID
SxspDbgPrintActivationContextGuidSection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Data,
    const GUID *ExtensionGuid,
    ULONG SectionId,
    PCSTR SectionName,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    SIZE_T cchPLP = rbuffPLP.Cch();
    CSmallStringBuffer buffFlags;
    CSmallStringBuffer buffBriefOutput;

    PCACTIVATION_CONTEXT_GUID_SECTION_ENTRY ElementList = NULL;
    PCACTIVATION_CONTEXT_GUID_SECTION_HASH_TABLE SearchStructure = NULL;
    PVOID UserData = NULL;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgGuidSectionFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_GUID_SECTION_ENTRIES_IN_ORDER, "Inorder")
    };

    if (PLP == NULL)
        PLP = L"";

    if (Data->ElementListOffset != 0)
        ElementList = (PCACTIVATION_CONTEXT_GUID_SECTION_ENTRY) (((ULONG_PTR) Data) + Data->ElementListOffset);

    if (Data->SearchStructureOffset != 0)
        SearchStructure = (PCACTIVATION_CONTEXT_GUID_SECTION_HASH_TABLE) (((ULONG_PTR) Data) + Data->SearchStructureOffset);

    if (Data->UserDataOffset != 0)
        UserData = (PVOID) (((ULONG_PTR) Data) + Data->UserDataOffset);

    ::FusionpFormatFlags(Data->Flags, fFull, NUMBER_OF(s_rgGuidSectionFlags), s_rgGuidSectionFlags, buffFlags);

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_GUID_SECTION_HEADER %p\n"
            "%S   Magic = 0x%08lx\n"
            "%S   HeaderSize = %u\n"
            "%S   FormatVersion = %u\n"
            "%S   DataFormatVersion = %u\n"
            "%S   Flags = 0x%08lx (%S)\n",
            PLP, Data,
            PLP, Data->Magic,
            PLP, Data->HeaderSize,
            PLP, Data->FormatVersion,
            PLP, Data->DataFormatVersion,
            PLP, Data->Flags, static_cast<PCWSTR>(buffFlags));

        ::FusionpDbgPrintEx(
            Level,
            "%S   ElementCount = %u\n"
            "%S   ElementListOffset = %d (-> %p)\n"
            "%S   SearchStructureOffset = %d (-> %p)\n"
            "%S   UserDataOffset = %d (-> %p)\n"
            "%S   UserDataSize = %u\n",
            PLP, Data->ElementCount,
            PLP, Data->ElementListOffset, ElementList,
            PLP, Data->SearchStructureOffset, SearchStructure,
            PLP, Data->UserDataOffset, UserData,
            PLP, Data->UserDataSize);

        if (UserData != NULL)
        {
            ::FusionpDbgPrintEx(
                Level,
                "%S   User data at %p (%d bytes)\n",
                PLP, UserData, Data->UserDataSize);

            rbuffPLP.Win32Append(L"   ", 3);
            FusionpDbgPrintBlob(Level, UserData, Data->UserDataSize, rbuffPLP);
            rbuffPLP.Left(cchPLP);
            PLP = rbuffPLP;
        }
    }
    else
    {
        ::FusionpDbgPrintEx(
            Level,
            "%S%s guid section (%lu entr%s; Flags: %S)\n"
            "%S   Key................................... | Value\n",
            PLP, SectionName, Data->ElementCount, Data->ElementCount == 1 ? "y" : "ies", static_cast<PCWSTR>(buffFlags),
            PLP);
    }

    if (fFull && (SearchStructure != NULL))
    {
        PCACTIVATION_CONTEXT_GUID_SECTION_HASH_BUCKET BucketTable = NULL;

        if (SearchStructure->BucketTableOffset != 0)
            BucketTable = (PCACTIVATION_CONTEXT_GUID_SECTION_HASH_BUCKET) (((ULONG_PTR) Data) + SearchStructure->BucketTableOffset);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ACTIVATION_CONTEXT_GUID_SECTION_HASH_TABLE %p\n"
            "%S      BucketTableEntryCount = %u\n"
            "%S      BucketTableOffset = %d (-> %p)\n",
            PLP, SearchStructure,
            PLP, SearchStructure->BucketTableEntryCount,
            PLP, SearchStructure->BucketTableOffset, BucketTable);

        if (BucketTable != NULL)
        {
            ULONG i;

            for (i=0; i<SearchStructure->BucketTableEntryCount; i++)
            {
                PLONG Entries = NULL;

                if (BucketTable[i].ChainOffset != 0)
                    Entries = (PLONG) (((ULONG_PTR) Data) + BucketTable[i].ChainOffset);

                ::FusionpDbgPrintEx(
                    Level,
                    "%S      ACTIVATION_CONTEXT_GUID_SECTION_HASH_BUCKET %p\n"
                    "%S         ChainCount = %u\n"
                    "%S         ChainOffset = %d (-> %p)\n",
                    PLP, &BucketTable[i],
                    PLP, BucketTable[i].ChainCount,
                    PLP, BucketTable[i].ChainOffset, Entries);

                if (Entries != NULL)
                {
                    ULONG j;

                    for (j=0; j<BucketTable[i].ChainCount; j++)
                    {
                        PVOID Entry = NULL;

                        if (Entries[j] != 0)
                            Entry = (PVOID) (((ULONG_PTR) Data) + Entries[j]);

                        ::FusionpDbgPrintEx(
                            Level,
                            "%S         Chain[%d] = %d (-> %p)\n",
                            PLP, j, Entries[j], Entry);
                    }
                }
            }
        }
    }

    if (ElementList != NULL)
    {
        ULONG i;
        CSmallStringBuffer buffFormattedGuid;

        for (i=0; i<Data->ElementCount; i++)
        {
            PVOID EntryData = NULL;

            ::SxspFormatGUID(ElementList[i].Guid, buffFormattedGuid);

            if (ElementList[i].Offset != 0)
                EntryData = (PVOID) (((ULONG_PTR) Data) + ElementList[i].Offset);

            if (fFull)
            {
                ::FusionpDbgPrintEx(
                    Level,
                    "%S   ACTIVATION_CONTEXT_GUID_SECTION_ENTRY #%d - %p\n"
                    "%S      Guid = %S\n"
                    "%S      AssemblyRosterIndex = %u\n",
                    PLP, i, &ElementList[i],
                    PLP, static_cast<PCWSTR>(buffFormattedGuid),
                    PLP, ElementList[i].AssemblyRosterIndex);

                ::FusionpDbgPrintEx(
                    Level,
                    "%S      Offset = %d (-> %p)\n"
                    "%S      Length = %u\n",
                    PLP, ElementList[i].Offset, EntryData,
                    PLP, ElementList[i].Length);
            }
            else
            {
                buffBriefOutput.Win32ResizeBuffer(cchPLP + 3 + 38 + 4, eDoNotPreserveBufferContents);
                buffBriefOutput.Win32Format(L"%s   %38s | ", PLP, static_cast<PCWSTR>(buffFormattedGuid));
            }

            if (EntryData != NULL)
            {
                if (ExtensionGuid == NULL)
                {
                    rbuffPLP.Win32Append(L"      ", 6);

                    switch (SectionId)
                    {
                    default:
                        ::FusionpDbgPrintBlob(Level, EntryData, ElementList[i].Length, rbuffPLP);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION:
                        ::SxspDbgPrintComServerRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION:
                        ::SxspDbgPrintComInterfaceRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION:
                        ::SxspDbgPrintTypeLibraryRedirection(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_COM_TYPE_LIBRARY_REDIRECTION) EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;

                    case ACTIVATION_CONTEXT_SECTION_CLR_SURROGATES:
                        ::SxspDbgPrintClrSurrogateTable(Level, fFull, Data, (PCACTIVATION_CONTEXT_DATA_CLR_SURROGATE)EntryData, ElementList[i].Length, rbuffPLP, buffBriefOutput);
                        break;
                    }

                    rbuffPLP.Left(cchPLP);
                    PLP = rbuffPLP;
                }
            }

            if (!fFull)
                ::FusionpDbgPrintEx(Level, "%S\n", static_cast<PCWSTR>(buffBriefOutput));
        }
    }
}

VOID
SxspDbgPrintAssemblyInformation(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    UNICODE_STRING s2, s3, s5, strIdentity;
    CSmallStringBuffer buffManifestLastWriteTime;
    CSmallStringBuffer buffPolicyLastWriteTime;
    CSmallStringBuffer buffFlags;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgAssemblyInformationFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_ROOT_ASSEMBLY, "Root Assembly")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_POLICY_APPLIED, "Policy Applied")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_ASSEMBLY_POLICY_APPLIED, "Assembly Policy Applied")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_ROOT_POLICY_APPLIED, "Root Policy Applied")
    };

    if (PLP == NULL)
        PLP = L"";

#define GET_STRING(_var, _elem) \
    if (Entry-> _elem ## Length != 0) \
    { \
        (_var).Length = (_var).MaximumLength = static_cast<USHORT>(Entry-> _elem ## Length); \
        (_var).Buffer = reinterpret_cast<PWSTR>(((LONG_PTR) Header) + Entry-> _elem ## Offset); \
    } \
    else \
    { \
        (_var).Length = (_var).MaximumLength = 0; \
        (_var).Buffer = NULL; \
        }

    GET_STRING(s2, ManifestPath);
    GET_STRING(s3, PolicyPath);
    GET_STRING(s5, AssemblyDirectoryName);

#undef GET_STRING

    // prepare data for print

    ::SxspFormatFileTime(Entry->ManifestLastWriteTime, buffManifestLastWriteTime);
    ::SxspFormatFileTime(Entry->PolicyLastWriteTime, buffPolicyLastWriteTime);

    ::FusionpFormatFlags(Entry->Flags, fFull, NUMBER_OF(s_rgAssemblyInformationFlags), s_rgAssemblyInformationFlags, buffFlags);

    if (Entry->EncodedAssemblyIdentityOffset != 0)
    {
        strIdentity.Buffer = (PWSTR) (((ULONG_PTR) Header) + Entry->EncodedAssemblyIdentityOffset);
        strIdentity.Length = static_cast<USHORT>(Entry->EncodedAssemblyIdentityLength);
        strIdentity.MaximumLength = static_cast<USHORT>(Entry->EncodedAssemblyIdentityLength);
    }
    else
    {
        strIdentity.Buffer = NULL;
        strIdentity.Length = 0;
        strIdentity.MaximumLength = 0;
    }

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION %p\n"
            "%S   Size = %lu\n"
            "%S   Flags = 0x%08lx (%S)\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags, static_cast<PCWSTR>(buffFlags));

        ::FusionpDbgPrintEx(
            Level,
            "%S   EncodedIdentity = %wZ\n",
            PLP, &strIdentity);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ManifestPathType = %lu\n"
            "%S   ManifestPath = \"%wZ\"\n",
            PLP, Entry->ManifestPathType,
            PLP, &s2);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ManifestLastWriteTime = %S\n",
            PLP, static_cast<PCWSTR>(buffManifestLastWriteTime));

        ::FusionpDbgPrintEx(
            Level,
            "%S   PolicyPathType = %lu\n"
            "%S   PolicyPath = \"%wZ\"\n"
            "%S   PolicyLastWriteTime = %S\n",
            PLP, Entry->PolicyPathType,
            PLP, &s3,
            PLP, static_cast<PCWSTR>(buffPolicyLastWriteTime));

        ::FusionpDbgPrintEx(
            Level,
            "%S   MetadataSatelliteRosterIndex = %lu\n"
            "%S   ManifestVersionMajor = %u\n"
            "%S   ManifestVersionMinor = %u\n",
            PLP, Entry->MetadataSatelliteRosterIndex,
            PLP, Entry->ManifestVersionMajor,
            PLP, Entry->ManifestVersionMinor);

        ::FusionpDbgPrintEx(
            Level,
            "%S   AssemblyDirectoryName = \"%wZ\"\n",
            PLP, &s5);
    }
    else
    {
        // abuse buffManifestLastWriteTime
        buffManifestLastWriteTime.Win32ResizeBuffer(((strIdentity.Length + s2.Length) / sizeof(WCHAR)) + 4, eDoNotPreserveBufferContents);
        buffManifestLastWriteTime.Win32Format(L"%wZ \"%wZ\"", &strIdentity, &s2);
        rbuffBriefOutput.Win32Append(buffManifestLastWriteTime);
    }
}

VOID
SxspDbgPrintDllRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_DLL_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    PCACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_SEGMENT PathSegments = NULL;
    CSmallStringBuffer buffFlags;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgDllRedirectionFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_INCLUDES_BASE_NAME, "Includes Base Name")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_OMITS_ASSEMBLY_ROOT, "Omits Assembly Root")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_EXPAND, "Req. EnvVar Expansion")
    };

    if (PLP == NULL)
        PLP = L"";

    if (Entry->PathSegmentOffset != 0)
        PathSegments = (PCACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_SEGMENT) (((ULONG_PTR) Header) + Entry->PathSegmentOffset);

    ::FusionpFormatFlags(Entry->Flags, fFull, NUMBER_OF(s_rgDllRedirectionFlags), s_rgDllRedirectionFlags, buffFlags);

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_DLL_REDIRECTION %p\n"
            "%S   Size = %u\n"
            "%S   Flags = 0x%08lx (%S)\n"
            "%S   TotalPathLength = %u (%u chars)\n"
            "%S   PathSegmentCount = %u\n"
            "%S   PathSegmentOffset = %d (-> %p)\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags, static_cast<PCWSTR>(buffFlags),
            PLP, Entry->TotalPathLength, Entry->TotalPathLength / sizeof(WCHAR),
            PLP, Entry->PathSegmentCount,
            PLP, Entry->PathSegmentOffset, PathSegments);
    }
    else
        rbuffBriefOutput.Win32Append(L"\"", 1);

    if (PathSegments != NULL)
    {
        ULONG i;

        for (i=0; i<Entry->PathSegmentCount; i++)
        {
            PCWSTR pwch = NULL;
            UNICODE_STRING s;

            if (PathSegments[i].Offset != 0)
            {
                pwch = (PCWSTR) (((ULONG_PTR) Header) + PathSegments[i].Offset);

                s.MaximumLength = static_cast<USHORT>(PathSegments[i].Length);
                s.Length = static_cast<USHORT>(PathSegments[i].Length);
                s.Buffer = (PWSTR) pwch;
            }
            else
            {
                s.MaximumLength = 0;
                s.Length = 0;
                s.Buffer = NULL;
            }

            if (fFull)
            {
                ::FusionpDbgPrintEx(
                    Level,
                    "%S   ACTIVATION_CONTEXT_DATA_DLL_REDIRECTION_PATH_SEGMENT #%d - %p\n"
                    "%S      Length = %u (%u chars)\n"
                    "%S      Offset = %d (-> %p)\n"
                    "%S         \"%wZ\"\n",
                    PLP, i, &PathSegments[i],
                    PLP, PathSegments[i].Length, PathSegments[i].Length / sizeof(WCHAR),
                    PLP, PathSegments[i].Offset, pwch,
                    PLP, &s);
            }
            else
            {
                rbuffBriefOutput.Win32Append(s.Buffer, s.Length / sizeof(WCHAR));
            }
        }
    }

    if (!fFull)
    {
        rbuffBriefOutput.Win32Append(L"\" (Flags: ", 10);
        rbuffBriefOutput.Win32Append(buffFlags);
        rbuffBriefOutput.Win32Append(L")", 1);
    }
}

VOID
SxspDbgPrintWindowClassRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_WINDOW_CLASS_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    UNICODE_STRING s1, s2;
    CSmallStringBuffer buffFlags;

#if 0 // replace when the list of flags is non-empty
    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgWCRedirectionFlags[] =
    {
    };
#endif // 0

    if (PLP == NULL)
        PLP = L"";

    memset(&s1, 0, sizeof(s1));
    memset(&s2, 0, sizeof(s2));

    ::FusionpFormatFlags(
        Entry->Flags,
        fFull,
#if 0 // replace when the list of flags is nonempty
        NUMBER_OF(s_rgWCRedirectionFlags), s_rgWCRedirectionFlags,
#else
        0, NULL,
#endif
        buffFlags);

    if (Entry->VersionSpecificClassNameOffset != 0)
    {
        s1.Length = static_cast<USHORT>(Entry->VersionSpecificClassNameLength);
        s1.MaximumLength = s1.Length;
        s1.Buffer = (PWSTR) (((ULONG_PTR) Entry) + Entry->VersionSpecificClassNameOffset);
    }

    if (Entry->DllNameOffset != 0)
    {
        s2.Length = static_cast<USHORT>(Entry->DllNameLength);
        s2.MaximumLength = s2.Length;
        s2.Buffer = (PWSTR) (((ULONG_PTR) Header) + Entry->DllNameOffset);
    }

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_WINDOW_CLASS_REDIRECTION %p\n"
            "%S   Size = %u\n"
            "%S   Flags = 0x%08lx\n"
            "%S   VersionSpecificClassNameLength = %u (%u chars)\n"
            "%S   VersionSpecificClassNameOffset = %d (-> %p)\n"
            "%S      \"%wZ\"\n"
            "%S   DllNameLength = %u (%u chars)\n"
            "%S   DllNameOffset = %d (-> %p)\n"
            "%S      \"%wZ\"\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags,
            PLP, Entry->VersionSpecificClassNameLength, Entry->VersionSpecificClassNameLength / sizeof(WCHAR),
            PLP, Entry->VersionSpecificClassNameOffset, s1.Buffer,
            PLP, &s1,
            PLP, Entry->DllNameLength, Entry->DllNameLength / sizeof(WCHAR),
            PLP, Entry->DllNameOffset, s2.Buffer,
            PLP, &s2);
    }
    else
    {
        rbuffBriefOutput.Win32Append(s1.Buffer, s1.Length / sizeof(WCHAR));
        rbuffBriefOutput.Win32Append(L" in ", 4);
        rbuffBriefOutput.Win32Append(s2.Buffer, s2.Length / sizeof(WCHAR));
        rbuffBriefOutput.Win32Append(L" (Flags: ", 9);
        rbuffBriefOutput.Win32Append(buffFlags);
        rbuffBriefOutput.Win32Append(L")", 1);
    }
}


VOID
SxspDbgPrintClrSurrogateTable(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_CLR_SURROGATE Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffGuid;
    UNICODE_STRING RuntimeVersion = RTL_CONSTANT_STRING(L"<No runtime version>");
    UNICODE_STRING TypeName = RTL_CONSTANT_STRING(L"<No type name>");

    if (PLP == NULL)
        PLP = L"";

    ::SxspFormatGUID(Entry->SurrogateIdent, buffGuid);

    if (Entry->VersionOffset != 0)
    {
        RuntimeVersion.MaximumLength = RuntimeVersion.Length = static_cast<USHORT>(Entry->VersionLength);
        RuntimeVersion.Buffer = (PWSTR)(((ULONG_PTR)Entry) + Entry->VersionOffset);
    }

    if (Entry->TypeNameOffset != 0)
    {
        TypeName.MaximumLength = TypeName.Length = static_cast<USHORT>(Entry->TypeNameLength);
        TypeName.Buffer = (PWSTR)(((ULONG_PTR)Entry) + Entry->TypeNameOffset);
    }

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_NDP_INTEROP %p\n"
            "%S   Size = %u\n"
            "%S   Flags = 0x%08lx\n"
            "%S   SurrogateIdent = %S\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags,
            PLP, static_cast<PCWSTR>(buffGuid));

        ::FusionpDbgPrintEx(
            Level,
            "%S   AssemblyName [Offset %u (-> %p), Length %u] = \"%wZ\"\n"
            "%S   RuntimeVersion [Offset %u (-> %p), Length %u] = \"%wZ\"\n",
            PLP, Entry->TypeNameOffset, TypeName.Buffer, Entry->TypeNameLength, &TypeName,
            PLP, Entry->VersionOffset, RuntimeVersion.Buffer, Entry->VersionLength, &RuntimeVersion
            );
    }
    else
    {
        rbuffBriefOutput.Win32Append(buffGuid);
        rbuffBriefOutput.Win32Append(L" runtime: '", NUMBER_OF(L" runtime: '")-1);
        rbuffBriefOutput.Win32Append(&RuntimeVersion);
        rbuffBriefOutput.Win32Append(L"' typename: '", NUMBER_OF(L"' typename: '")-1);
        rbuffBriefOutput.Win32Append(&TypeName);
        rbuffBriefOutput.Win32Append(L"'", 1);
    }
    
}


VOID
SxspDbgPrintComServerRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffConfiguredClsid;
    CSmallStringBuffer buffImplementedClsid;
    CSmallStringBuffer buffReferenceClsid;
    CSmallStringBuffer buffTypeLibraryId;
    CSmallStringBuffer buffThreadingModel;
    UNICODE_STRING s;
    UNICODE_STRING progid;

    if (PLP == NULL)
        PLP = L"";

    memset(&s, 0, sizeof(s));

    ::SxspFormatGUID(Entry->ReferenceClsid, buffReferenceClsid);
    ::SxspFormatGUID(Entry->ConfiguredClsid, buffConfiguredClsid);
    ::SxspFormatGUID(Entry->ImplementedClsid, buffImplementedClsid);

    if (Entry->TypeLibraryId == GUID_NULL)
        buffTypeLibraryId.Win32Assign(L"<none>", 6);
    else
        ::SxspFormatGUID(Entry->TypeLibraryId, buffTypeLibraryId);

    ::SxspFormatThreadingModel(Entry->ThreadingModel, buffThreadingModel);

    if (Entry->ModuleOffset != 0)
    {
        s.Length = static_cast<USHORT>(Entry->ModuleLength);
        s.MaximumLength = s.Length;
        s.Buffer = (PWSTR) (((ULONG_PTR) Header) + Entry->ModuleOffset);
    }

    if (Entry->ProgIdOffset != 0)
    {
        progid.Length = static_cast<USHORT>(Entry->ProgIdLength);
        progid.MaximumLength = progid.Length;
        progid.Buffer = (PWSTR) (((ULONG_PTR) Entry) + Entry->ProgIdOffset);
    }
    else
    {
        progid.Length = 0;
        progid.MaximumLength = 0;
        progid.Buffer = NULL;
    }

    if (fFull)
    {
        PCACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION_SHIM ShimData = NULL;

        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION %p\n"
            "%S   Size = %u\n"
            "%S   Flags = 0x%08lx\n"
            "%S   ThreadingModel = %u (%S)\n"
            "%S   ReferenceClsid = %S\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags,
            PLP, Entry->ThreadingModel, static_cast<PCWSTR>(buffThreadingModel),
            PLP, static_cast<PCWSTR>(buffReferenceClsid));

        ::FusionpDbgPrintEx(
            Level,
            "%S   ConfiguredClsid = %S\n"
            "%S   ImplementedClsid = %S\n"
            "%S   TypeLibraryId = %S\n"
            "%S   ModuleLength = %u (%u chars)\n"
            "%S   ModuleOffset = %d (-> %p)\n"
            "%S      \"%wZ\"\n",
            PLP, static_cast<PCWSTR>(buffConfiguredClsid),
            PLP, static_cast<PCWSTR>(buffImplementedClsid),
            PLP, static_cast<PCWSTR>(buffTypeLibraryId),
            PLP, Entry->ModuleLength, Entry->ModuleLength / sizeof(WCHAR),
            PLP, Entry->ModuleOffset, s.Buffer,
            PLP, &s);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ProgIdLength = %lu\n"
            "%S   ProgIdOffset = %ld (-> %p)\n"
            "%S      \"%wZ\"\n",
            PLP, Entry->ProgIdLength,
            PLP, Entry->ProgIdOffset, progid.Buffer,
            PLP, &progid);

        if (Entry->ShimDataOffset != 0)
            ShimData = (PCACTIVATION_CONTEXT_DATA_COM_SERVER_REDIRECTION_SHIM) (((ULONG_PTR) Entry) + Entry->ShimDataOffset);

        ::FusionpDbgPrintEx(
            Level,
            "%S   ShimDataLength = %lu\n"
            "%S   ShimDataOffset = %ld (-> %p)\n",
            PLP, Entry->ShimDataLength,
            PLP, Entry->ShimDataOffset, ShimData);

        if (ShimData != NULL)
        {
            ::FusionpDbgPrintEx(
                Level,
                "%S      Size = %lu\n"
                "%S      Flags = 0x%08lx\n"
                "%S      Type = %lu\n",
                PLP, ShimData->Size,
                PLP, ShimData->Flags,
                PLP, ShimData->Type);

            if (ShimData->ModuleOffset != 0)
            {
                s.Buffer = (PWSTR) (((ULONG_PTR) Header) + ShimData->ModuleOffset);
                s.Length = (USHORT) ShimData->ModuleLength;
                s.MaximumLength = (USHORT) ShimData->ModuleLength;
            }
            else
            {
                s.Buffer = NULL;
                s.Length = 0;
                s.MaximumLength = 0;
            }

            ::FusionpDbgPrintEx(
                Level,
                "%S      ModuleLength = %lu\n"
                "%S      ModuleOffset = %lu (-> %p)\n"
                "%S         \"%wZ\"\n",
                PLP, ShimData->ModuleLength,
                PLP, ShimData->ModuleOffset, s.Buffer,
                PLP, &s);

            if (ShimData->TypeOffset != 0)
            {
                s.Buffer = (PWSTR) (((ULONG_PTR) ShimData) + ShimData->TypeOffset);
                s.Length = (USHORT) ShimData->TypeLength;
                s.MaximumLength = (USHORT) ShimData->TypeLength;
            }
            else
            {
                s.Buffer = NULL;
                s.Length = 0;
                s.MaximumLength = 0;
            }

            ::FusionpDbgPrintEx(
                Level,
                "%S      TypeLength = %lu\n"
                "%S      TypeOffset = %lu (-> %p)\n"
                "%S         \"%wZ\"\n",
                PLP, ShimData->TypeLength,
                PLP, ShimData->TypeOffset, s.Buffer,
                PLP, &s);

            if (ShimData->ShimVersionOffset != 0)
            {
                s.Buffer = (PWSTR) (((ULONG_PTR) ShimData) + ShimData->ShimVersionOffset);
                s.Length = (USHORT) ShimData->ShimVersionLength;
                s.MaximumLength = (USHORT) ShimData->ShimVersionLength;
            }
            else
            {
                s.Buffer = NULL;
                s.Length = 0;
                s.MaximumLength = 0;
            }

            ::FusionpDbgPrintEx(
                Level,
                "%S      ShimVersionLength = %lu\n"
                "%S      ShimVersionOffset = %lu (-> %p)\n"
                "%S         \"%wZ\"\n",
                PLP, ShimData->ShimVersionLength,
                PLP, ShimData->ShimVersionOffset, s.Buffer,
                PLP, &s);
        }
    }
    else
    {
        rbuffBriefOutput.Win32Append(buffConfiguredClsid);

        rbuffBriefOutput.Win32Append(L" ", 1);
        rbuffBriefOutput.Win32Append(s.Buffer, s.Length / sizeof(WCHAR));
        if (progid.Length != 0)
        {
            rbuffBriefOutput.Win32Append(L" progid: ", 9);
            rbuffBriefOutput.Win32Append(progid.Buffer, progid.Length / sizeof(WCHAR));
        }
    }

}

VOID
FusionpDbgPrintStringInUntruncatedChunks(
    ULONG   Level,
    PCWSTR  String,
    SIZE_T  Length
    )
//
// in pieces so it does not get truncated by DbgPrint (or we could use OutputDebugString, which
// does this same work)
//
{
    if (!::FusionpDbgWouldPrintAtFilterLevel(Level))
        return;
    while (Length != 0)
    {
        SIZE_T ShortLength = ((Length > 128) ? 128 : Length);

        CUnicodeString UnicodeString(String, ShortLength);
        ::FusionpDbgPrintEx(Level, "%wZ", &UnicodeString);

        Length -= ShortLength;
        String += ShortLength;
    }
}

VOID
FusionpDbgPrintStringInUntruncatedChunks(
    ULONG Level,
    const CBaseStringBuffer &rbuff
    )
{
    if (!::FusionpDbgWouldPrintAtFilterLevel(Level))
        return;

    FusionpDbgPrintStringInUntruncatedChunks(Level, rbuff, rbuff.Cch());
}

VOID
SxspDbgPrintTypeLibraryRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_TYPE_LIBRARY_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    if (!::FusionpDbgWouldPrintAtFilterLevel(Level))
        return;

    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buff;

    UNICODE_STRING Name = RTL_CONSTANT_STRING(L"");
    UNICODE_STRING HelpDir = RTL_CONSTANT_STRING(L"");
    ACTIVATION_CONTEXT_DATA_TYPE_LIBRARY_VERSION Version = { 0 };

    if (!buff.Win32ResizeBuffer(4096, eDoNotPreserveBufferContents))
        return;

#if 1
#define GET_STRING(ntstr, struc, struc_size, offset_field, length_field, base) \
    do { if (RTL_CONTAINS_FIELD((struc), (struc_size), offset_field) \
          && RTL_CONTAINS_FIELD((struc), (struc_size), length_field) \
          && (struc)->offset_field != 0  \
          && (struc)->length_field != 0) \
    { \
        (ntstr).Length = static_cast<USHORT>(struc->length_field - sizeof((ntstr).Buffer[0])); \
        (ntstr).Buffer = const_cast<PWSTR>(reinterpret_cast<PCWSTR>(struc->offset_field + reinterpret_cast<PCBYTE>(base))); \
    } } while(0)

    GET_STRING(Name, Entry, Entry->Size, NameOffset, NameLength, Header);
    GET_STRING(HelpDir, Entry, Entry->Size, HelpDirOffset, HelpDirLength, Entry);

#undef GET_STRING

#else

    if (RTL_CONTAINS_FIELD(Entry, Entry->Size, NameLength)
        && RTL_CONTAINS_FIELD(Entry, Entry->Size, NameOffset)
        && Entry->NameOffset != 0
        )
    {
        Name.Length = static_cast<USHORT>(Entry->NameLength);
        Name.Buffer = const_cast<PWSTR>(reinterpret_cast<PCWSTR>(Entry->NameOffset + reinterpret_cast<PCBYTE>(Header)));
    }

    if (RTL_CONTAINS_FIELD(Entry, Entry->Size, HelpDirLength)
        && RTL_CONTAINS_FIELD(Entry, Entry->Size, HelpDirOffset)
        && Entry->HelpDirOffset != 0
        )
    {
        HelpDir.Length = static_cast<USHORT>(Entry->HelpDirLength);
        HelpDir.Buffer = const_cast<PWSTR>(reinterpret_cast<PCWSTR>(Entry->HelpDirOffset + reinterpret_cast<PCBYTE>(Entry)));
    }

#endif

    if (RTL_CONTAINS_FIELD(Entry, Entry->Size, Version))
        Version = Entry->Version;

    if (!buff.Win32Format(
        L"%SACTIVATION_CONTEXT_DATA_COM_TYPE_LIBRARY_REDIRECTION %p\n"
        L"%S   Size = 0x%lx\n"
        L"%S   Flags = 0x%lx\n"
        L"%S   Name = %wZ (offset 0x%lx + %p = %p)\n"
        L"%S   HelpDir = %wZ (offset 0x%lx + %p = %p)\n"
        L"%S   Version = 0x%lx.%lx\n",
        PLP, Entry,
        PLP, static_cast<ULONG>(Entry->Size),
        PLP, static_cast<ULONG>(Entry->Flags),
        PLP, &Name, static_cast<ULONG>(Entry->NameOffset), static_cast<PCVOID>(Header), static_cast<PCVOID>(Name.Buffer),
        PLP, &HelpDir, static_cast<ULONG>(Entry->HelpDirOffset), static_cast<PCVOID>(Entry), static_cast<PCVOID>(HelpDir.Buffer),
        PLP, static_cast<ULONG>(Version.Major), static_cast<ULONG>(Version.Minor)
        ))
        return;

    ::FusionpDbgPrintStringInUntruncatedChunks(Level, buff);
}

VOID
SxspDbgPrintComProgIdRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_STRING_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_PROGID_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
//    CSmallStringBuffer buffFlags;
    CSmallStringBuffer buffClsid;
    const GUID *pcguid = NULL;

    if (Entry->ConfiguredClsidOffset != 0)
    {
        pcguid = (const GUID *) (((ULONG_PTR) Header) + Entry->ConfiguredClsidOffset);
        ::SxspFormatGUID(*pcguid, buffClsid);
    }

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_COM_PROGID_REDIRECTION %p\n"
            "%S   Size = %lu (0x%lx)\n"
            "%S   Flags = 0x%08lx\n"
            "%S   ConfiguredClsidOffset = %lu (-> %p)\n"
            "%S      %S\n",
            PLP, Entry,
            PLP, Entry->Size, Entry->Size,
            PLP, Entry->Flags,
            PLP, Entry->ConfiguredClsidOffset, pcguid,
            PLP, static_cast<PCWSTR>(buffClsid));
    }
    else
    {
        rbuffBriefOutput.Win32Append(buffClsid);
    }
}

VOID
SxspDbgPrintComInterfaceRedirection(
    ULONG Level,
    bool fFull,
    PCACTIVATION_CONTEXT_GUID_SECTION_HEADER Header,
    PCACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION Entry,
    SIZE_T Length,
    CBaseStringBuffer &rbuffPLP,
    CBaseStringBuffer &rbuffBriefOutput
    )
{
    PCWSTR PLP = rbuffPLP;
    CSmallStringBuffer buffProxyStubClsid32;
    CSmallStringBuffer buffBaseInterface;
    CSmallStringBuffer buffFlags;
    CSmallStringBuffer buffTypeLibraryId;
    UNICODE_STRING s;

    static const FUSION_FLAG_FORMAT_MAP_ENTRY s_rgComInterfaceFlags[] =
    {
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION_FLAG_NUM_METHODS_VALID, "NumMethods Valid")
        DEFINE_FUSION_FLAG_FORMAT_MAP_ENTRY(ACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION_FLAG_BASE_INTERFACE_VALID, "BaseInterface Valid")
    };

    if (PLP == NULL)
        PLP = L"";

    memset(&s, 0, sizeof(s));

    ::SxspFormatGUID(Entry->ProxyStubClsid32, buffProxyStubClsid32);
    ::SxspFormatGUID(Entry->BaseInterface, buffBaseInterface);

    ::FusionpFormatFlags(Entry->Flags, fFull, NUMBER_OF(s_rgComInterfaceFlags), s_rgComInterfaceFlags, buffFlags);

    if (Entry->TypeLibraryId == GUID_NULL)
        buffTypeLibraryId.Win32Assign(L"<none>", 6);
    else
        ::SxspFormatGUID(Entry->TypeLibraryId, buffTypeLibraryId);

    if (Entry->NameOffset != 0)
    {
        s.Length = static_cast<USHORT>(Entry->NameLength);
        s.MaximumLength = s.Length;
        s.Buffer = (PWSTR) (((ULONG_PTR) Entry) + Entry->NameOffset);
    }

    if (fFull)
    {
        ::FusionpDbgPrintEx(
            Level,
            "%SACTIVATION_CONTEXT_DATA_COM_INTERFACE_REDIRECTION %p\n"
            "%S   Size = %lu\n"
            "%S   Flags = 0x%08lx (%S)\n",
            PLP, Entry,
            PLP, Entry->Size,
            PLP, Entry->Flags, static_cast<PCWSTR>(buffFlags));

        ::FusionpDbgPrintEx(
            Level,
            "%S   ProxyStubClsid32 = %S\n"
            "%S   NumMethods = %lu\n"
            "%S   TypeLibraryId = %S\n",
            PLP, static_cast<PCWSTR>(buffProxyStubClsid32),
            PLP, Entry->NumMethods,
            PLP, static_cast<PCWSTR>(buffTypeLibraryId));

        ::FusionpDbgPrintEx(
            Level,
            "%S   BaseInterface = %S\n"
            "%S   NameLength = %lu (%u chars)\n"
            "%S   NameOffset = %lu (-> %p)\n",
            PLP, static_cast<PCWSTR>(buffBaseInterface),
            PLP, Entry->NameLength, (Entry->NameLength / sizeof(WCHAR)),
            PLP, Entry->NameOffset, s.Buffer);

        ::FusionpDbgPrintEx(
            Level,
            "%S      \"%wZ\"\n",
            PLP, &s);
    }
    else
    {
        rbuffBriefOutput.Win32Append(buffProxyStubClsid32);
        rbuffBriefOutput.Win32Append(L" ", 1);
        rbuffBriefOutput.Win32Append(s.Buffer, s.Length / sizeof(WCHAR));
    }
}

VOID
SxspDbgPrintInstallSourceInfo(
    ULONG Level,
    bool fFull,
    PSXS_INSTALL_SOURCE_INFO Info,
    CBaseStringBuffer &rbuffPLP
    )
{
    PCWSTR PLP = rbuffPLP;
    if ( !PLP ) PLP = L"SXS.DLL:";
    if ( !Info )
    {
        ::FusionpDbgPrintEx( Level, "%S InstallationInfo is null!\n", PLP );
    }
    else
    {
        DWORD dwFlags = Info->dwFlags;

        ::FusionpDbgPrintEx(
            Level,
            "%S InstallationInfo at 0x%08x - size = %d\n",
            "%S   Flag set: %s catalog, %s codebase, %s prompt, %s in setup mode\n"
            "%S   Codebase Name: %ls\n"
            "%S   Prompt: %ls\n",
            PLP, Info, Info->cbSize,
            PLP,
                dwFlags & SXSINSTALLSOURCE_HAS_CATALOG ? "has" : "no",
                dwFlags & SXSINSTALLSOURCE_HAS_CODEBASE ? "has" : "no",
                dwFlags & SXSINSTALLSOURCE_HAS_PROMPT ? "has" : "no",
                dwFlags & SXSINSTALLSOURCE_INSTALLING_SETUP ? "is" : "not",
            PLP, Info->pcwszCodebaseName,
            PLP, Info->pcwszPromptOnRefresh);
    }
}