lib vs 生成pdb_使用VS API开发一个PDB Dumper并且可以在没装VS2010的计算机上运行

#include"Dia2.h"#include"..\..\..\..\..\Library\Stream\Accessor.h"#include"..\..\..\..\..\Library\Stream\CharFormat.h"#include"..\..\..\..\..\Library\Stream\FileStream.h"#include"..\..\..\..\..\Librar

野树长生

162人浏览 · 2021-01-14 20:16:50

野树长生 · 2021-01-14 20:16:50 发布

#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"usingnamespacevl;usingnamespacevl::collections;usingnamespacevl::stream;namespacedumppdb

{//--------------------------------------------------------------------voidPrintString(TextWriter&file,constwchar_t*text,intlen=-1)

{if(len==-1) len=(int)wcslen(text);

file.WriteString(text, len);

}voidPrintSpaces(TextWriter&file,intlevel)

{for(inti=0;i

}voidPrintEscapedName(TextWriter&file,constwchar_t*name)

{constwchar_t*head=name;constwchar_t*reading=head;while(*reading)

{switch(*reading)

{caseL'

PrintString(file, head, reading-head);

PrintString(file, L"<");

head=reading+1;

reading=head;break;caseL'>':

PrintString(file, head, reading-head);

PrintString(file, L">");

head=reading+1;

reading=head;break;caseL'&':

PrintString(file, head, reading-head);

PrintString(file, L"&");

head=reading+1;

reading=head;break;caseL'\"':

PrintString(file, head, reading-head);

PrintString(file, L""");

head=reading+1;

reading=head;break;default:

reading++;

}

}

PrintString(file, head, reading-head);

}voidPrintXMLOpen(

TextWriter&file,intlevel,constwchar_t*tagName,constwchar_t*symbolName

,constwchar_t*a1=0,constwchar_t*v1=0,constwchar_t*a2=0,constwchar_t*v2=0,constwchar_t*a3=0,constwchar_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");

}voidPrintXMLClose(TextWriter&file,intlevel,constwchar_t*tagName)

{

PrintSpaces(file, level);

PrintString(file, L"");

PrintString(file, tagName);

PrintString(file, L">\r\n");

}//--------------------------------------------------------------------DictionaryudtSymbols;

DictionaryfuncSymbols;voidAddOrRelease(Dictionary&symbols, IDiaSymbol*symbol)

{//get nameBSTR nameBSTR=0;if(SUCCEEDED(symbol->get_name(&nameBSTR))&&nameBSTR)

{

WString name=nameBSTR;if(!symbols.Keys().Contains(name))

{//record class symbolsymbols.Add(name, symbol);

symbol=0;

}

}if(symbol) symbol->Release();

}voidAddUdtOrRelease(IDiaSymbol*udtType)

{

AddOrRelease(udtSymbols, udtType);

}voidAddFuncOrRelease(IDiaSymbol*funcSymbol)

{

AddOrRelease(funcSymbols, funcSymbol);

}voidFindClasses(IDiaSymbol*exeSymbol)

{

{//enumerate classesIDiaEnumSymbols*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 enumsIDiaEnumSymbols*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 compilandsIDiaEnumSymbols*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 functionsIDiaEnumSymbols*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();

}

}

}//--------------------------------------------------------------------constwchar_t*GetAccessName(enumCV_access_e access)

{switch(access)

{caseCV_private:returnL"private";caseCV_protected:returnL"protected";caseCV_public:returnL"public";default:returnL"";

}

}constwchar_t*GetCallingConversionName(enumCV_call_e callconv)

{switch(callconv)

{caseCV_CALL_NEAR_C:returnL"cdecl";caseCV_CALL_NEAR_FAST:returnL"fastcall";caseCV_CALL_NEAR_STD:returnL"stdcall";caseCV_CALL_NEAR_SYS:returnL"syscall";caseCV_CALL_THISCALL:returnL"thiscall";caseCV_CALL_CLRCALL:returnL"clrcall";default:returnL"";

}

}constwchar_t*GetBasicTypeName(enumBasicType type,intlength)

{switch(type)

{casebtVoid:returnL"void";casebtChar:returnL"char";casebtWChar:returnL"wchar_t";casebtInt:casebtLong:returnlength==1?L"signed __int8":length==2?L"signed __int16":length==4?L"signed __int32":length==8?L"signed __int64":L"[UnknownSInt]";casebtUInt:casebtULong:returnlength==1?L"unsigned __int8":length==2?L"unsigned __int16":length==4?L"unsigned __int32":length==8?L"unsigned __int64":L"[UnknownUInt]";casebtFloat:returnlength==4?L"float":length==8?L"double":L"[UnknownFloat]";casebtBool:returnL"bool";casebtBCD:returnL"[BCD]";casebtCurrency:returnL"[Currency]";casebtDate:returnL"[Date]";casebtVariant:returnL"[Variant]";casebtComplex:returnL"[Complex]";casebtBit:returnL"[Bit]";casebtBSTR:returnL"[BSTR]";casebtHresult:returnL"[HRESULT]";default:returnL"[NoType]";

}

}//--------------------------------------------------------------------externvoidDumpType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel);voidDumpTypeHelper(TextWriter&file, IDiaSymbol*typeSymbol,intlevel,constwchar_t*tagName,constwchar_t*symbolName,boolclose=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);

}

}voidDumpFunctionType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{

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

}voidDumpPointerType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{

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

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

}

}voidDumpArrayType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{

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);intelementCount=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();

}

}voidDumpBaseType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{enumBasicType 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));

}

}voidDumpEnumType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{

BSTR nameBSTR=0;if(SUCCEEDED(typeSymbol->get_name(&nameBSTR))&&nameBSTR)

{

DumpTypeHelper(file, typeSymbol, level, L"enumType", nameBSTR);

}

}voidDumpUserType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{

BSTR nameBSTR=0;if(SUCCEEDED(typeSymbol->get_name(&nameBSTR))&&nameBSTR)

{

DumpTypeHelper(file, typeSymbol, level, L"classType", nameBSTR);

}

}voidDumpType(TextWriter&file, IDiaSymbol*typeSymbol,intlevel)

{enumSymTagEnum symTag=SymTagNull;

typeSymbol->get_symTag((DWORD*)&symTag);switch(symTag)

{caseSymTagFunctionType:returnDumpFunctionType(file, typeSymbol, level);caseSymTagPointerType:returnDumpPointerType(file, typeSymbol, level);caseSymTagArrayType:returnDumpArrayType(file, typeSymbol, level);caseSymTagBaseType:returnDumpBaseType(file, typeSymbol, level);caseSymTagEnum:returnDumpUserType(file, typeSymbol, level);caseSymTagUDT:returnDumpUserType(file, typeSymbol, level);

}

}voidDumpSymbolType(TextWriter&file, IDiaSymbol*symbolWithType,intsymbolLevel)

{

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

}

}//--------------------------------------------------------------------voidDumpBaseClasses(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");

}voidDumpNestedClasses(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");

}voidDumpTypedefs(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");

}voidDumpFields(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)

{enumDataKind dataKind;if(SUCCEEDED(fieldSymbol->get_dataKind((DWORD*)&dataKind))&&(dataKind==DataIsMember||dataKind==DataIsStaticMember||dataKind==DataIsConstant))

{enumCV_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");

}elseif(dataKind==DataIsStaticMember)

{

PrintXMLOpen(file,3, L"staticField", nameBSTR, L"access", GetAccessName(access));

DumpSymbolType(file, fieldSymbol,3);

PrintXMLClose(file,3, L"staticField");

}elseif(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)

{caseVT_I1:

ivalue=value.cVal;gotoPROCESS_INTEGER;caseVT_I2:

ivalue=value.iVal;gotoPROCESS_INTEGER;caseVT_I4:

ivalue=value.lVal;gotoPROCESS_INTEGER;caseVT_UI1:

ivalue=value.bVal;gotoPROCESS_INTEGER;caseVT_UI2:

ivalue=value.uiVal;gotoPROCESS_INTEGER;caseVT_UI4:

ivalue=value.ulVal;gotoPROCESS_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");

}voidDumpMethodArguments(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)

{enumDataKind 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");

}voidDumpMethod(TextWriter&file, IDiaSymbol*methodSymbol)

{enumCV_access_e access;

methodSymbol->get_access((DWORD*)&access);

BOOL staticMethod=FALSE;

methodSymbol->get_isStatic(&staticMethod);

BSTR nameBSTR=0;constwchar_t*virtualValue=L"normal";

BOOL virtualBool=FALSE;if(SUCCEEDED(methodSymbol->get_pure(&virtualBool))&&virtualBool)

{

virtualValue=L"pure";

}elseif(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");

}

}

}voidDumpMethods(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");

}voidDump(TextWriter&file, IDiaSymbol*exeSymbol)

{

FindClasses(exeSymbol);for(inti=0;i

{

WString className=udtSymbols.Keys()[i];

IDiaSymbol*classSymbol=udtSymbols.Values()[i];enumSymTagEnum 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");

}elseif(symTag==SymTagEnum)

{

PrintXMLOpen(file,1, L"enum", className.Buffer());

DumpFields(file, classSymbol);

PrintXMLClose(file,1, L"enum");

}

}for(inti=0;i

{

udtSymbols.Values()[i]->Release();

}

udtSymbols.Clear();

PrintXMLOpen(file,1, L"functions", NULL);for(inti=0;i

{

WString funcName=funcSymbols.Keys()[i];

IDiaSymbol*funcSymbol=funcSymbols.Values()[i];

DumpMethod(file, funcSymbol);

}

PrintXMLClose(file,1, L"functions");for(inti=0;i

{

funcSymbols.Values()[i]->Release();

}

funcSymbols.Clear();

}voidDumpPdbToXml(IDiaSymbol*exeSymbol,constwchar_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");

}

}

DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

cover

KingbaseES数据库：医疗信创潮涌沅江，国产化信创打造医疗新质生产力

DAMO开发者矩阵

cover

告别迁移焦虑：金仓KDMS V4带你轻松搞定数据库国产化替代

DAMO开发者矩阵

cover

KingbaseES数据库在常德二院全栈国产化信创中产生新质生产力,医疗信创的部署如何实现，如何操作？

DAMO开发者矩阵

所有评论(0)

查看更多评论

野树长生

@weixin_32460203

已为社区贡献3条内容