GacUI到了撰写文档的时候了。虽然GacUI本身的功能还没有全部完成，但是发布一个alpha版还是可以的。因此GacUI需要一份文档。自从.net语言支持XML注释生成文档之后，Visual Studio的本地C++也支持使用XML注释了。只要打开了[工程属性 -> C/C++ -> Output Files -> Generate XML Documentation Files]之后，Visual Studio会在编译本地C++工程之后，将所有的XML注释收集起来，放在和可执行文件同一个目录下的<ProjectName.xml>里面。然后我就尝试bing了一下有没有从C++的XML文档生成可读文档的工具，结果发现只有.net才支持。
后来我稍微研究了一下（详细内容将会在下一篇博客透露），发现之所以没人写这个工具，是因为只有.net的可执行文件才包含足够多的元数据，而且这些元数据是必须的，否则无法生成一个完整的文档。举个例子，虽然<ProjectName.xml>包含了xml注释和该注释所在的符号，但是却没有包含该符号的结构信息。结果你试图生成一个函数的文档的时候，发现你获取不到它的返回类型！不过这也是情有可原的，因为本地C++程序根本就没有元数据。
由此我联想到了之前写程序读pdb的时候的一些内容，我想到pdb生成的那份xml显然是可以当成元数据的。而且我找到了一个方法，让你在使用Visual Studio2010的PDB API
msdia100.dll的时候，可以不需要安装Visual Studio 2010了。下面就来介绍PDB Dumper的代码。
首先是main函数。main函数做的工作跟
之前的这篇博客说的一样，当然还是要创建一个IDiaSymbol的COM对象。一般来说，COM对象是需要被注册到windows里面（基本上都在注册表里）才能使用CoCreateInstance来创建。但是后来我发现msdia100.dll十分良心，还提供了一个NoRegCoCreate函数，可以在你只有msdia100.dll但却没有注册它的COM对象的情况下创建该对象：
#include <Windows.h>
#include <iostream>
#include <string>
#include "dia2.h"
#include "diacreate.h"
#pragma comment(lib, "diaguids.lib")
namespace dumppdb
{
extern void DumpPdbToXml(IDiaSymbol* exeSymbol, const wchar_t* xml);
}
IDiaSymbol* CreateDiaSymbol(const wchar_t* pdbPath)
{
IDiaDataSource* pSource=0;
IDiaSession* pSession=0;
IDiaSymbol* pSymbol=0;
CoInitialize(NULL);
//HRESULT hr = CoCreateInstance(
// CLSID_DiaSource,
// NULL,
// CLSCTX_INPROC_SERVER,
// IID_IDiaDataSource,
// (void**) &pSource
// );
HRESULT hr = NoRegCoCreate(
L"msdia100.dll",
CLSID_DiaSource,
IID_IDiaDataSource,
(void**) &pSource
);
if(SUCCEEDED(hr))
if(SUCCEEDED(pSource->loadDataFromPdb(pdbPath)))
if(SUCCEEDED(pSource->openSession(&pSession)))
if(SUCCEEDED(pSession->get_globalScope(&pSymbol)))
{
return pSymbol;
}
return 0;
}
int wmain(int argc, wchar_t* argv[])
{
if(argc==3)
{
std::wcout<<L"importing "<<argv[1]<<std::endl;
IDiaSymbol* exeSymbol=CreateDiaSymbol(argv[1]);
if(exeSymbol)
{
std::wcout<<L"exporting "<<argv[2]<<std::endl;
dumppdb::DumpPdbToXml(exeSymbol, argv[2]);
std::wcout<<L"exported "<<argv[2]<<std::endl;
}
else
{
std::wcout<<L"Failed to read pdb("<<argv[1]<<L")"<<std::endl;
}
}
else
{
std::wcout<<L"Pdb2Xml.exe <pdb-path> <xml-path>"<<std::endl;
}
return 0;
}
这里的dia2.h、diacreate.h、diaguids.lib和msdia100.dll都可以在C:\Program Files (x86)\Microsoft Visual Studio 10.0\DIA SDK下找到。我们需要做的就是将这些文件都复制到我们的工程目录下面。至于如何读取IDiaSymbol的内容，各位就自己查MSDN了。下面贴出我使用IDiaSymbol将PDB的关键内容输出成xml的函数，也就是上面的代码提到的DumpPdbToXml函数了：
#include "Dia2.h"
#include "..\..\..\..\..\Library\Stream\Accessor.h"
#include "..\..\..\..\..\Library\Stream\CharFormat.h"
#include "..\..\..\..\..\Library\Stream\FileStream.h"
#include "..\..\..\..\..\Library\Stream\CacheStream.h"
#include "..\..\..\..\..\Library\Collections\Dictionary.h"
using namespace vl;
using namespace vl::collections;
using namespace vl::stream;
namespace dumppdb
{
//--------------------------------------------------------------------
void PrintString(TextWriter& file, const wchar_t* text, int len=-1)
{
if(len==-1) len=(int)wcslen(text);
file.WriteString(text, len);
}
void PrintSpaces(TextWriter& file, int level)
{
for(int i=0;i<level;i++) PrintString(file, L" ");
}
void PrintEscapedName(TextWriter& file, const wchar_t* name)
{
const wchar_t* head=name;
const wchar_t* reading=head;
while(*reading)
{
switch(*reading)
{
case L'<':
PrintString(file, head, reading-head);
PrintString(file, L"<");
head=reading+1;
reading=head;
break;
case L'>':
PrintString(file, head, reading-head);
PrintString(file, L">");
head=reading+1;
reading=head;
break;
case L'&':
PrintString(file, head, reading-head);
PrintString(file, L"&");
head=reading+1;
reading=head;
break;
case L'\"':
PrintString(file, head, reading-head);
PrintString(file, L""");
head=reading+1;
reading=head;
break;
default:
reading++;
}
}
PrintString(file, head, reading-head);
}
void PrintXMLOpen(
TextWriter& file, int level, const wchar_t* tagName, const wchar_t* symbolName
,const wchar_t* a1=0, const wchar_t* v1=0
,const wchar_t* a2=0, const wchar_t* v2=0
,const wchar_t* a3=0, const wchar_t* v3=0
)
{
PrintSpaces(file, level);
PrintString(file, L"<");
PrintString(file, tagName);
if(symbolName)
{
PrintString(file, L" name=\"");
PrintEscapedName(file, symbolName);
PrintString(file, L"\"");
}
if(a1)
{
PrintString(file, L" ");
PrintString(file, a1);
PrintString(file, L"=\"");
PrintEscapedName(file, v1);
PrintString(file, L"\"");
}
if(a2)
{
PrintString(file, L" ");
PrintString(file, a2);
PrintString(file, L"=\"");
PrintEscapedName(file, v2);
PrintString(file, L"\"");
}
if(a3)
{
PrintString(file, L" ");
PrintString(file, a3);
PrintString(file, L"=\"");
PrintEscapedName(file, v3);
PrintString(file, L"\"");
}
PrintString(file, L" >\r\n");
}
void PrintXMLClose(TextWriter& file, int level, const wchar_t* tagName)
{
PrintSpaces(file, level);
PrintString(file, L"</");
PrintString(file, tagName);
PrintString(file, L">\r\n");
}
//--------------------------------------------------------------------
Dictionary<WString, IDiaSymbol*> udtSymbols;
Dictionary<WString, IDiaSymbol*> funcSymbols;
void AddOrRelease(Dictionary<WString, IDiaSymbol*>& symbols, IDiaSymbol* symbol)
{
// get name
BSTR nameBSTR=0;
if(SUCCEEDED(symbol->get_name(&nameBSTR)) && nameBSTR)
{
WString name=nameBSTR;
if(!symbols.Keys().Contains(name))
{
// record class symbol
symbols.Add(name, symbol);
symbol=0;
}
}
if(symbol) symbol->Release();
}
void AddUdtOrRelease(IDiaSymbol* udtType)
{
AddOrRelease(udtSymbols, udtType);
}
void AddFuncOrRelease(IDiaSymbol* funcSymbol)
{
AddOrRelease(funcSymbols, funcSymbol);
}
void FindClasses(IDiaSymbol* exeSymbol)
{
{
// enumerate classes
IDiaEnumSymbols* udtEnum=0;
if(SUCCEEDED(exeSymbol->findChildren(SymTagUDT, NULL, nsNone, &udtEnum)))
{
DWORD udtCelt=0;
IDiaSymbol* udtSymbol=0;
while(SUCCEEDED(udtEnum->Next(1, &udtSymbol, &udtCelt)) && udtSymbol && udtCelt)
{
AddUdtOrRelease(udtSymbol);
}
}
}
{
// enumerate enums
IDiaEnumSymbols* enumEnum=0;
if(SUCCEEDED(exeSymbol->findChildren(SymTagEnum, NULL, nsNone, &enumEnum)))
{
DWORD enumCelt=0;
IDiaSymbol* enumSymbol=0;
while(SUCCEEDED(enumEnum->Next(1, &enumSymbol, &enumCelt)) && enumSymbol && enumCelt)
{
AddUdtOrRelease(enumSymbol);
}
}
}
{
// enumerate compilands
IDiaEnumSymbols* compilandEnum=0;
if(SUCCEEDED(exeSymbol->findChildren(SymTagCompiland, NULL, nsNone, &compilandEnum)))
{
DWORD compilandCelt=0;
IDiaSymbol* compilandSymbol=0;
while(SUCCEEDED(compilandEnum->Next(1, &compilandSymbol, &compilandCelt)) && compilandSymbol && compilandCelt)
{
// enumerate functions
IDiaEnumSymbols* functionEnum=0;
if(SUCCEEDED(compilandSymbol->findChildren(SymTagFunction, NULL, nsNone, &functionEnum)))
{
DWORD functionCelt=0;
IDiaSymbol* functionSymbol=0;
while(SUCCEEDED(functionEnum->Next(1, &functionSymbol, &functionCelt)) && functionSymbol && functionCelt)
{
IDiaSymbol* udtType=0;
if(SUCCEEDED(functionSymbol->get_classParent(&udtType)) && udtType)
{
AddUdtOrRelease(udtType);
functionSymbol->Release();
}
else
{
AddFuncOrRelease(functionSymbol);
}
}
functionEnum->Release();
}
compilandSymbol->Release();
}
compilandEnum->Release();
}
}
}
//--------------------------------------------------------------------
const wchar_t* GetAccessName(enum CV_access_e access)
{
switch(access)
{
case CV_private: return L"private";
case CV_protected: return L"protected";
case CV_public: return L"public";
default: return L"";
}
}
const wchar_t* GetCallingConversionName(enum CV_call_e callconv)
{
switch(callconv)
{
case CV_CALL_NEAR_C: return L"cdecl";
case CV_CALL_NEAR_FAST: return L"fastcall";
case CV_CALL_NEAR_STD: return L"stdcall";
case CV_CALL_NEAR_SYS: return L"syscall";
case CV_CALL_THISCALL: return L"thiscall";
case CV_CALL_CLRCALL: return L"clrcall";
default: return L"";
}
}
const wchar_t* GetBasicTypeName(enum BasicType type, int length)
{
switch(type)
{
case btVoid: return L"void";
case btChar: return L"char";
case btWChar: return L"wchar_t";
case btInt:
case btLong: return length==1?L"signed __int8":length==2?L"signed __int16":length==4?L"signed __int32":length==8?L"signed __int64":L"[UnknownSInt]";
case btUInt:
case btULong: return length==1?L"unsigned __int8":length==2?L"unsigned __int16":length==4?L"unsigned __int32":length==8?L"unsigned __int64":L"[UnknownUInt]";
case btFloat: return length==4?L"float":length==8?L"double":L"[UnknownFloat]";
case btBool: return L"bool";
case btBCD: return L"[BCD]";
case btCurrency: return L"[Currency]";
case btDate: return L"[Date]";
case btVariant: return L"[Variant]";
case btComplex: return L"[Complex]";
case btBit: return L"[Bit]";
case btBSTR: return L"[BSTR]";
case btHresult: return L"[HRESULT]";
default: return L"[NoType]";
}
}
//--------------------------------------------------------------------
extern void DumpType(TextWriter& file, IDiaSymbol* typeSymbol, int level);
void DumpTypeHelper(TextWriter& file, IDiaSymbol* typeSymbol, int level, const wchar_t* tagName, const wchar_t* symbolName, bool close=true)
{
BOOL constType=FALSE, volatileType=FALSE;
typeSymbol->get_constType(&constType);
typeSymbol->get_volatileType(&volatileType);
PrintXMLOpen(file, level, tagName, symbolName, L"const", (constType?L"true":L"false"), L"volatile", (volatileType?L"true":L"false"));
if(close)
{
PrintXMLClose(file, level, tagName);
}
}
void DumpFunctionType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
DumpTypeHelper(file, typeSymbol, level, L"function", NULL, false);
{
CV_call_e callconv;
typeSymbol->get_callingConvention((DWORD*)&callconv);
PrintXMLOpen(file, level+1, L"callconv", NULL, L"value", GetCallingConversionName(callconv));
PrintXMLClose(file, level+1, L"callconv");
PrintXMLOpen(file, level+1, L"arguments", NULL);
{
IDiaEnumSymbols* argumentEnum=0;
if(SUCCEEDED(typeSymbol->findChildren(SymTagFunctionArgType, NULL, nsNone, &argumentEnum)) && argumentEnum)
{
DWORD argumentCelt=0;
IDiaSymbol* argumentSymbol=0;
while(SUCCEEDED(argumentEnum->Next(1, &argumentSymbol, &argumentCelt)) && argumentSymbol && argumentCelt)
{
IDiaSymbol* argumentType=0;
if(SUCCEEDED(argumentSymbol->get_type(&argumentType)))
{
PrintXMLOpen(file, level+2, L"argument", NULL);
DumpType(file, argumentType, level+3);
PrintXMLClose(file, level+2, L"argument");
argumentType->Release();
}
argumentSymbol->Release();
}
argumentEnum->Release();
}
}
PrintXMLClose(file, level+1, L"arguments");
}
IDiaSymbol* returnTypeSymbol=0;
if(SUCCEEDED(typeSymbol->get_type(&returnTypeSymbol)) && returnTypeSymbol)
{
PrintXMLOpen(file, level+1, L"return", NULL);
DumpType(file, returnTypeSymbol, level+2);
PrintXMLClose(file, level+1, L"return");
returnTypeSymbol->Release();
}
PrintXMLClose(file, level, L"function");
}
void DumpPointerType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
IDiaSymbol* elementTypeSymbol=0;
if(SUCCEEDED(typeSymbol->get_type(&elementTypeSymbol)) && elementTypeSymbol)
{
BOOL lref=FALSE;
BOOL rref=FALSE;
typeSymbol->get_reference(&lref);
typeSymbol->get_RValueReference(&rref);
if(lref)
{
DumpTypeHelper(file, typeSymbol, level, L"reference", NULL, false);
DumpType(file, elementTypeSymbol, level+1);
PrintXMLClose(file, level, L"reference");
}
else if(rref)
{
DumpTypeHelper(file, typeSymbol, level, L"rightValueReference", NULL, false);
DumpType(file, elementTypeSymbol, level+1);
PrintXMLClose(file, level, L"rightValueReference");
}
else
{
DumpTypeHelper(file, typeSymbol, level, L"pointer", NULL, false);
DumpType(file, elementTypeSymbol, level+1);
PrintXMLClose(file, level, L"pointer");
}
elementTypeSymbol->Release();
}
}
void DumpArrayType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
IDiaSymbol* indexTypeSymbol=0;
IDiaSymbol* elementTypeSymbol=0;
if(SUCCEEDED(typeSymbol->get_type(&elementTypeSymbol)) && elementTypeSymbol)
{
ULONGLONG arraySize=0, elementSize=0;
typeSymbol->get_length(&arraySize);
elementTypeSymbol->get_length(&elementSize);
int elementCount=arraySize?(int)(arraySize/elementSize):0;
wchar_t elementCountBuffer[20];
_itow_s(elementCount, elementCountBuffer, 10);
DumpTypeHelper(file, typeSymbol, level, L"array", NULL, false);
PrintXMLOpen(file, level+1, L"count", NULL, L"value", elementCountBuffer);
PrintXMLClose(file, level+1, L"count");
if(SUCCEEDED(typeSymbol->get_arrayIndexType(&indexTypeSymbol)) && indexTypeSymbol)
{
PrintXMLOpen(file, level+1, L"index", NULL);
DumpType(file, indexTypeSymbol, level+2);
PrintXMLClose(file, level+1, L"index");
indexTypeSymbol->Release();
}
PrintXMLOpen(file, level+1, L"element", NULL);
DumpType(file, elementTypeSymbol, level+2);
PrintXMLClose(file, level+1, L"element");
PrintXMLClose(file, level, L"array");
elementTypeSymbol->Release();
}
}
void DumpBaseType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
enum BasicType basicType=btNoType;
ULONGLONG length=0;
if(SUCCEEDED(typeSymbol->get_baseType((DWORD*)&basicType)) && SUCCEEDED(typeSymbol->get_length(&length)))
{
DumpTypeHelper(file, typeSymbol, level, L"primitive", GetBasicTypeName(basicType, (int)length));
}
}
void DumpEnumType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
BSTR nameBSTR=0;
if(SUCCEEDED(typeSymbol->get_name(&nameBSTR)) && nameBSTR)
{
DumpTypeHelper(file, typeSymbol, level, L"enumType", nameBSTR);
}
}
void DumpUserType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
BSTR nameBSTR=0;
if(SUCCEEDED(typeSymbol->get_name(&nameBSTR)) && nameBSTR)
{
DumpTypeHelper(file, typeSymbol, level, L"classType", nameBSTR);
}
}
void DumpType(TextWriter& file, IDiaSymbol* typeSymbol, int level)
{
enum SymTagEnum symTag=SymTagNull;
typeSymbol->get_symTag((DWORD*)&symTag);
switch(symTag)
{
case SymTagFunctionType:
return DumpFunctionType(file, typeSymbol, level);
case SymTagPointerType:
return DumpPointerType(file, typeSymbol, level);
case SymTagArrayType:
return DumpArrayType(file, typeSymbol, level);
case SymTagBaseType:
return DumpBaseType(file, typeSymbol, level);
case SymTagEnum:
return DumpUserType(file, typeSymbol, level);
case SymTagUDT:
return DumpUserType(file, typeSymbol, level);
}
}
void DumpSymbolType(TextWriter& file, IDiaSymbol* symbolWithType, int symbolLevel)
{
IDiaSymbol* typeSymbol=0;
if(SUCCEEDED(symbolWithType->get_type(&typeSymbol)) && typeSymbol)
{
PrintXMLOpen(file, symbolLevel+1, L"type", NULL);
DumpType(file, typeSymbol, symbolLevel+2);
PrintXMLClose(file, symbolLevel+1, L"type");
typeSymbol->Release();
}
}
//--------------------------------------------------------------------
void DumpBaseClasses(TextWriter& file, IDiaSymbol* udtSymbol)
{
PrintXMLOpen(file, 2, L"baseClasses", NULL, false);
IDiaEnumSymbols* baseClassEnum=0;
if(SUCCEEDED(udtSymbol->findChildren(SymTagBaseClass, NULL, nsNone, &baseClassEnum)) && baseClassEnum)
{
DWORD baseClassCelt=0;
IDiaSymbol* baseClassSymbol=0;
while(SUCCEEDED(baseClassEnum->Next(1, &baseClassSymbol, &baseClassCelt)) && baseClassSymbol && baseClassCelt)
{
CV_access_e access=CV_public;
baseClassSymbol->get_access((DWORD*)&access);
BSTR nameBSTR=0;
if(SUCCEEDED(baseClassSymbol->get_name(&nameBSTR)) && nameBSTR)
{
PrintXMLOpen(file, 3, L"baseClass", nameBSTR, L"access", GetAccessName(access));
PrintXMLClose(file, 3, L"baseClass");
}
baseClassSymbol->Release();
}
baseClassEnum->Release();
}
PrintXMLClose(file, 2, L"baseClasses");
}
void DumpNestedClasses(TextWriter& file, IDiaSymbol* udtSymbol)
{
PrintXMLOpen(file, 2, L"nestedClasses", NULL, false);
IDiaEnumSymbols* nestedClassEnum=0;
if(SUCCEEDED(udtSymbol->findChildren(SymTagUDT, NULL, nsNone, &nestedClassEnum)) && nestedClassEnum)
{
DWORD nestedClassCelt=0;
IDiaSymbol* nestedClassSymbol=0;
while(SUCCEEDED(nestedClassEnum->Next(1, &nestedClassSymbol, &nestedClassCelt)) && nestedClassSymbol && nestedClassCelt)
{
BSTR nameBSTR=0;
if(SUCCEEDED(nestedClassSymbol->get_name(&nameBSTR)) && nameBSTR)
{
PrintXMLOpen(file, 3, L"nestedClass", nameBSTR);
PrintXMLClose(file, 3, L"nestedClass");
}
nestedClassSymbol->Release();
}
nestedClassEnum->Release();
}
PrintXMLClose(file, 2, L"nestedClasses");
}
void DumpTypedefs(TextWriter& file, IDiaSymbol* udtSymbol)
{
PrintXMLOpen(file, 2, L"typedefs", NULL, false);
IDiaEnumSymbols* typedefEnum=0;
if(SUCCEEDED(udtSymbol->findChildren(SymTagTypedef, NULL, nsNone, &typedefEnum)) && typedefEnum)
{
DWORD typedefCelt=0;
IDiaSymbol* typedefSymbol=0;
while(SUCCEEDED(typedefEnum->Next(1, &typedefSymbol, &typedefCelt)) && typedefSymbol && typedefCelt)
{
BSTR nameBSTR=0;
if(SUCCEEDED(typedefSymbol->get_name(&nameBSTR)) && nameBSTR)
{
PrintXMLOpen(file, 3, L"typedef", nameBSTR);
DumpSymbolType(file, typedefSymbol, 3);
PrintXMLClose(file, 3, L"typedef");
}
typedefSymbol->Release();
}
typedefEnum->Release();
}
PrintXMLClose(file, 2, L"typedefs");
}
void DumpFields(TextWriter& file, IDiaSymbol* udtSymbol)
{
PrintXMLOpen(file, 2, L"fields", NULL);
IDiaEnumSymbols* fieldEnum=0;
if(SUCCEEDED(udtSymbol->findChildren(SymTagData, NULL, nsNone, &fieldEnum)) && fieldEnum)
{
DWORD fieldCelt=0;
IDiaSymbol* fieldSymbol=0;
while(SUCCEEDED(fieldEnum->Next(1, &fieldSymbol, &fieldCelt)) && fieldSymbol && fieldCelt)
{
enum DataKind dataKind;
if(SUCCEEDED(fieldSymbol->get_dataKind((DWORD*)&dataKind)) && (dataKind==DataIsMember || dataKind==DataIsStaticMember || dataKind==DataIsConstant))
{
enum CV_access_e access;
fieldSymbol->get_access((DWORD*)&access);
BSTR nameBSTR=0;
if(SUCCEEDED(fieldSymbol->get_name(&nameBSTR)) && nameBSTR)
{
if(dataKind==DataIsMember)
{
PrintXMLOpen(file, 3, L"field", nameBSTR, L"access", GetAccessName(access));
DumpSymbolType(file, fieldSymbol, 3);
PrintXMLClose(file, 3, L"field");
}
else if(dataKind==DataIsStaticMember)
{
PrintXMLOpen(file, 3, L"staticField", nameBSTR, L"access", GetAccessName(access));
DumpSymbolType(file, fieldSymbol, 3);
PrintXMLClose(file, 3, L"staticField");
}
else if(dataKind==DataIsConstant)
{
PrintXMLOpen(file, 3, L"const", nameBSTR, L"access", GetAccessName(access));
DumpSymbolType(file, fieldSymbol, 3);
{
VARIANT value;
value.vt = VT_EMPTY;
if (fieldSymbol->get_value(&value) == S_OK)
{
signed __int64 ivalue=0;
switch(value.vt)
{
case VT_I1:
ivalue=value.cVal;
goto PROCESS_INTEGER;
case VT_I2:
ivalue=value.iVal;
goto PROCESS_INTEGER;
case VT_I4:
ivalue=value.lVal;
goto PROCESS_INTEGER;
case VT_UI1:
ivalue=value.bVal;
goto PROCESS_INTEGER;
case VT_UI2:
ivalue=value.uiVal;
goto PROCESS_INTEGER;
case VT_UI4:
ivalue=value.ulVal;
goto PROCESS_INTEGER;
PROCESS_INTEGER:
wchar_t valueBuffer[100];
_i64tow_s(ivalue, valueBuffer, 100, 10);
PrintXMLOpen(file, 4, L"intValue", NULL, L"value", valueBuffer);
PrintXMLClose(file, 4, L"intValue");
break;
}
}
}
PrintXMLClose(file, 3, L"const");
}
}
}
fieldSymbol->Release();
}
fieldEnum->Release();
}
PrintXMLClose(file, 2, L"fields");
}
void DumpMethodArguments(TextWriter& file, IDiaSymbol* methodSymbol)
{
PrintXMLOpen(file, 4, L"arguments", NULL);
IDiaEnumSymbols* argumentEnum=0;
if(SUCCEEDED(methodSymbol->findChildren(SymTagData, NULL, nsNone, &argumentEnum)) && argumentEnum)
{
DWORD argumentCelt=0;
IDiaSymbol* argumentSymbol=0;
while(SUCCEEDED(argumentEnum->Next(1, &argumentSymbol, &argumentCelt)) && argumentSymbol && argumentCelt)
{
enum DataKind dataKind;
if(SUCCEEDED(argumentSymbol->get_dataKind((DWORD*)&dataKind)) && dataKind==DataIsParam)
{
BSTR nameBSTR=0;
if(SUCCEEDED(argumentSymbol->get_name(&nameBSTR)) && nameBSTR)
{
PrintXMLOpen(file, 5, L"argument", nameBSTR);
DumpSymbolType(file, argumentSymbol, 5);
PrintXMLClose(file, 5, L"argument");
}
}
argumentSymbol->Release();
}
argumentEnum->Release();
}
PrintXMLClose(file, 4, L"arguments");
}
void DumpMethod(TextWriter& file, IDiaSymbol* methodSymbol)
{
enum CV_access_e access;
methodSymbol->get_access((DWORD*)&access);
BOOL staticMethod=FALSE;
methodSymbol->get_isStatic(&staticMethod);
BSTR nameBSTR=0;
const wchar_t* virtualValue=L"normal";
BOOL virtualBool=FALSE;
if(SUCCEEDED(methodSymbol->get_pure(&virtualBool)) && virtualBool)
{
virtualValue=L"pure";
}
else if(SUCCEEDED(methodSymbol->get_virtual(&virtualBool)) && virtualBool)
{
virtualValue=L"virtual";
}
if(SUCCEEDED(methodSymbol->get_name(&nameBSTR)) && nameBSTR)
{
if(staticMethod)
{
PrintXMLOpen(file, 3, L"staticMethod", nameBSTR, L"access", GetAccessName(access), L"virtual", virtualValue);
DumpMethodArguments(file, methodSymbol);
DumpSymbolType(file, methodSymbol, 3);
PrintXMLClose(file, 3, L"staticMethod");
}
else
{
PrintXMLOpen(file, 3, L"method", nameBSTR, L"access", GetAccessName(access), L"virtual", virtualValue);
DumpMethodArguments(file, methodSymbol);
DumpSymbolType(file, methodSymbol, 3);
PrintXMLClose(file, 3, L"method");
}
}
}
void DumpMethods(TextWriter& file, IDiaSymbol* udtSymbol)
{
PrintXMLOpen(file, 2, L"methods", NULL);
IDiaEnumSymbols* methodEnum=0;
if(SUCCEEDED(udtSymbol->findChildren(SymTagFunction, NULL, nsNone, &methodEnum)) && methodEnum)
{
DWORD methodCelt=0;
IDiaSymbol* methodSymbol=0;
while(SUCCEEDED(methodEnum->Next(1, &methodSymbol, &methodCelt)) && methodSymbol && methodCelt)
{
DumpMethod(file, methodSymbol);
methodSymbol->Release();
}
methodEnum->Release();
}
PrintXMLClose(file, 2, L"methods");
}
void Dump(TextWriter& file, IDiaSymbol* exeSymbol)
{
FindClasses(exeSymbol);
for(int i=0;i<udtSymbols.Count();i++)
{
WString className=udtSymbols.Keys()[i];
IDiaSymbol* classSymbol=udtSymbols.Values()[i];
enum SymTagEnum symTag=SymTagNull;
classSymbol->get_symTag((DWORD*)&symTag);
if(symTag==SymTagUDT)
{
PrintXMLOpen(file, 1, L"class", className.Buffer());
DumpBaseClasses(file, classSymbol);
DumpNestedClasses(file, classSymbol);
DumpTypedefs(file, classSymbol);
DumpFields(file, classSymbol);
DumpMethods(file, classSymbol);
PrintXMLClose(file, 1, L"class");
}
else if(symTag==SymTagEnum)
{
PrintXMLOpen(file, 1, L"enum", className.Buffer());
DumpFields(file, classSymbol);
PrintXMLClose(file, 1, L"enum");
}
}
for(int i=0;i<udtSymbols.Count();i++)
{
udtSymbols.Values()[i]->Release();
}
udtSymbols.Clear();
PrintXMLOpen(file, 1, L"functions", NULL);
for(int i=0;i<funcSymbols.Count();i++)
{
WString funcName=funcSymbols.Keys()[i];
IDiaSymbol* funcSymbol=funcSymbols.Values()[i];
DumpMethod(file, funcSymbol);
}
PrintXMLClose(file, 1, L"functions");
for(int i=0;i<funcSymbols.Count();i++)
{
funcSymbols.Values()[i]->Release();
}
funcSymbols.Clear();
}
void DumpPdbToXml(IDiaSymbol* exeSymbol, const wchar_t* xml)
{
FileStream fileStream(xml, FileStream::WriteOnly);
CacheStream cacheStream(fileStream, 1048576);
BomEncoder encoder(BomEncoder::Utf16);
EncoderStream encoderStream(cacheStream, encoder);
StreamWriter file(encoderStream);
PrintString(file, L"<?xml version=\"1.0\" encoding=\"utf-16\" ?>\r\n");
PrintXMLOpen(file, 0, L"pdb", NULL);
Dump(file, exeSymbol);
PrintXMLClose(file, 0, L"pdb");
}
}
下一篇文章将讲到我如何使用上面的程序产生的xml和Visual Studio的本地C++编译器生成的XML文档，来合并成一个完整的XML描述的文档。
posted on 2012-03-09 14:43
陈梓瀚(vczh) 阅读(7001)
评论(0) 编辑 收藏 引用 所属分类:
C++ 、
GacUI