mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
519 lines
11 KiB
519 lines
11 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
// C Binding for PDB, DBI, TPI, and Mod
|
|
|
|
#include "pdbimpl.h"
|
|
#include "dbiimpl.h"
|
|
|
|
extern "C" {
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenValidate(SZ szPDB, SZ szPath, SZ szMode, SIG sig, AGE age,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::OpenValidate (szPDB, szPath, szMode, sig, age, pec, szError, pppdb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenValidateEx(SZ szPDB, SZ szPathOrig, SZ szSearchPath, SZ szMode, SIG sig, AGE age,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::OpenValidateEx (szPDB, szPathOrig, szSearchPath, szMode, sig, age, pec, szError, pppdb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpen(SZ szPDB, SZ szMode, SIG sigInitial,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::Open(szPDB, szMode, sigInitial, pec, szError, pppdb);
|
|
}
|
|
|
|
// interfaces with cbPage
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenValidate2(SZ szPDB, SZ szPath, SZ szMode, SIG sig, AGE age, long cbPage,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::OpenValidate2 (szPDB, szPath, szMode, sig, age, cbPage, pec, szError, pppdb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenValidateEx2(SZ szPDB, SZ szPathOrig, SZ szSearchPath, SZ szMode, SIG sig, AGE age, long cbPage,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::OpenValidateEx2 (szPDB, szPathOrig, szSearchPath, szMode, sig, age, cbPage, pec, szError, pppdb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenEx(SZ szPDB, SZ szMode, SIG sigInitial, long cbPage,
|
|
OUT EC* pec, OUT char szError[cbErrMax], OUT PDB** pppdb)
|
|
{
|
|
return PDB::OpenEx(szPDB, szMode, sigInitial, cbPage, pec, szError, pppdb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBExportValidateInterface(INTV intv)
|
|
{
|
|
return PDB::ExportValidateInterface(intv);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(EC)
|
|
PDBQueryLastError(PDB* ppdb, OUT char szError[cbErrMax])
|
|
{
|
|
return ppdb->QueryLastError(szError);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(INTV)
|
|
PDBQueryInterfaceVersion(PDB* ppdb)
|
|
{
|
|
return ppdb->QueryInterfaceVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(IMPV)
|
|
PDBQueryImplementationVersion(PDB* ppdb)
|
|
{
|
|
return ppdb->QueryImplementationVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(SZ)
|
|
PDBQueryPDBName(PDB* ppdb, OUT char szPDB[_MAX_PATH])
|
|
{
|
|
return ppdb->QueryPDBName(szPDB);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(SIG)
|
|
PDBQuerySignature(PDB* ppdb)
|
|
{
|
|
return ppdb->QuerySignature();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(AGE)
|
|
PDBQueryAge(PDB* ppdb)
|
|
{
|
|
return ppdb->QueryAge();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBCreateDBI(PDB* ppdb, SZ_CONST szTarget, OUT DBI** ppdbi)
|
|
{
|
|
return ppdb->CreateDBI(szTarget, ppdbi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenDBI(PDB* ppdb, SZ_CONST szMode, SZ_CONST szTarget, OUT DBI** ppdbi)
|
|
{
|
|
return ppdb->OpenDBI(szTarget, szMode, ppdbi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenTpi(PDB* ppdb, SZ_CONST szMode, OUT TPI** pptpi)
|
|
{
|
|
return ppdb->OpenTpi(szMode, pptpi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBCommit(PDB* ppdb)
|
|
{
|
|
return ppdb->Commit();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBClose(PDB* ppdb)
|
|
{
|
|
return ppdb->Close();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
PDBOpenStream(PDB* ppdb, SZ_CONST szStream, OUT Stream** ppstream)
|
|
{
|
|
return ppdb->OpenStream(szStream, ppstream);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(CB)
|
|
StreamQueryCb(Stream* pstream)
|
|
{
|
|
return pstream->QueryCb();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamRead(Stream* pstream, OFF off, void* pvBuf, CB* pcbBuf)
|
|
{
|
|
return pstream->Read(off, pvBuf, pcbBuf);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamWrite(Stream* pstream, OFF off, void* pvBuf, CB cbBuf)
|
|
{
|
|
return pstream->Write(off, pvBuf, cbBuf);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamReplace(Stream* pstream, void* pvBuf, CB cbBuf)
|
|
{
|
|
return pstream->Replace(pvBuf, cbBuf);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamAppend(Stream* pstream, void* pvBuf, CB cbBuf)
|
|
{
|
|
return pstream->Append(pvBuf, cbBuf);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamDelete(Stream* pstream)
|
|
{
|
|
return pstream->Delete();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
StreamRelease(Stream* pstream)
|
|
{
|
|
return pstream->Release();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(INTV)
|
|
DBIQueryInterfaceVersion(DBI* pdbi)
|
|
{
|
|
return pdbi->QueryInterfaceVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(IMPV)
|
|
DBIQueryImplementationVersion(DBI* pdbi)
|
|
{
|
|
return pdbi->QueryImplementationVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIOpenMod(DBI* pdbi, SZ_CONST szModule, SZ_CONST szFile, OUT Mod** ppmod)
|
|
{
|
|
return pdbi->OpenMod(szModule, szFile, ppmod);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIDeleteMod(DBI* pdbi, SZ_CONST szModule)
|
|
{
|
|
return pdbi->DeleteMod(szModule);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIQueryNextMod(DBI* pdbi, Mod* pmod, Mod** ppmodNext)
|
|
{
|
|
return pdbi->QueryNextMod(pmod, ppmodNext);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIOpenGlobals(DBI* pdbi, OUT GSI **ppgsi)
|
|
{
|
|
return pdbi->OpenGlobals(ppgsi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIOpenPublics(DBI* pdbi, OUT GSI **ppgsi)
|
|
{
|
|
return pdbi->OpenPublics(ppgsi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIAddSec(DBI* pdbi, ISECT isect, USHORT flags, OFF off, CB cb)
|
|
{
|
|
return pdbi->AddSec(isect, flags, off, cb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIAddPublic(DBI* pdbi, SZ_CONST szPublic, ISECT isect, OFF off)
|
|
{
|
|
return pdbi->AddPublic(szPublic, isect, off);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIQueryModFromAddr(DBI* pdbi, ISECT isect, OFF off, OUT Mod** ppmod,
|
|
OUT ISECT* pisect, OUT OFF* poff, OUT CB* pcb)
|
|
{
|
|
return pdbi->QueryModFromAddr(isect, off, ppmod, pisect, poff, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIQuerySecMap(DBI* pdbi, OUT PB pb, CB* pcb)
|
|
{
|
|
return pdbi->QuerySecMap(pb, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIQueryFileInfo(DBI*pdbi, OUT PB pb, CB* pcb)
|
|
{
|
|
return pdbi->QueryFileInfo(pb, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
DBIDumpMods(DBI* pdbi)
|
|
{
|
|
pdbi->DumpMods();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
DBIDumpSecContribs(DBI* pdbi)
|
|
{
|
|
pdbi->DumpSecContribs();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
DBIDumpSecMap(DBI* pdbi)
|
|
{
|
|
pdbi->DumpSecMap();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIClose(DBI* pdbi)
|
|
{
|
|
return pdbi->Close();
|
|
}
|
|
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIAddThunkMap(DBI* pdbi, OFF* poffThunkMap, UINT nThunks, CB cbSizeOfThunk,
|
|
SO* psoSectMap, UINT nSects, ISECT isectThunkTable, OFF offThunkTable)
|
|
{
|
|
return pdbi->AddThunkMap(poffThunkMap, nThunks, cbSizeOfThunk, psoSectMap, nSects, isectThunkTable, offThunkTable);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
DBIGetEnumContrib(DBI* pdbi, OUT Enum** ppenum)
|
|
{
|
|
return pdbi->getEnumContrib(ppenum);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(INTV)
|
|
ModQueryInterfaceVersion(Mod* pmod)
|
|
{
|
|
return pmod->QueryInterfaceVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(IMPV)
|
|
ModQueryImplementationVersion(Mod* pmod)
|
|
{
|
|
return pmod->QueryImplementationVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModAddTypes(Mod* pmod, PB pbTypes, CB cb)
|
|
{
|
|
return pmod->AddTypes(pbTypes, cb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModAddSymbols(Mod* pmod, PB pbSym, CB cb)
|
|
{
|
|
return pmod->AddSymbols(pbSym, cb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModAddPublic(Mod* pmod, SZ_CONST szPublic, ISECT isect, OFF off)
|
|
{
|
|
return pmod->AddPublic(szPublic, isect, off);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModAddLines(Mod* pmod, SZ_CONST szSrc, ISECT isect, OFF offCon, CB cbCon,
|
|
OFF doff, LINE lineStart, PB pbCoff, CB cbCoff)
|
|
{
|
|
return pmod->AddLines(szSrc, isect, offCon, cbCon, doff, lineStart, pbCoff, cbCoff);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModAddSecContrib(Mod* pmod, ISECT isect, OFF off, CB cb, DWORD dwCharacteristics)
|
|
{
|
|
return pmod->AddSecContrib(isect, off, cb, dwCharacteristics);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryCBName(Mod* pmod, OUT CB* pcb)
|
|
{
|
|
return pmod->QueryCBName(pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryName(Mod* pmod, OUT char szName[_MAX_PATH], OUT CB* pcb)
|
|
{
|
|
return pmod->QueryName(szName, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQuerySymbols(Mod* pmod, PB pbSym, CB* pcb)
|
|
{
|
|
return pmod->QuerySymbols(pbSym, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryLines(Mod* pmod, PB pbLines, CB* pcb)
|
|
{
|
|
return pmod->QueryLines(pbLines, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModSetPvClient(Mod* pmod, void *pvClient)
|
|
{
|
|
return pmod->SetPvClient(pvClient);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModGetPvClient(Mod* pmod, OUT void** ppvClient)
|
|
{
|
|
return pmod->GetPvClient(ppvClient);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQuerySecContrib(Mod *pmod, OUT ISECT* pisect, OUT OFF* poff, OUT CB* pcb, OUT DWORD* pdwCharacteristics)
|
|
{
|
|
return pmod->QuerySecContrib(pisect, poff, pcb, pdwCharacteristics);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryImod(Mod* pmod, OUT IMOD* pimod)
|
|
{
|
|
return pmod->QueryImod(pimod);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryDBI(Mod* pmod, OUT DBI** ppdbi)
|
|
{
|
|
return pmod->QueryDBI(ppdbi);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModClose(Mod* pmod)
|
|
{
|
|
return pmod->Close();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryCBFile(Mod* pmod, OUT CB* pcb)
|
|
{
|
|
return pmod->QueryCBFile(pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
ModQueryFile(Mod* pmod, OUT char szFile[_MAX_PATH], OUT CB* pcb)
|
|
{
|
|
return pmod->QueryFile(szFile, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(INTV)
|
|
TypesQueryInterfaceVersion(TPI* ptpi)
|
|
{
|
|
return ptpi->QueryInterfaceVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(IMPV)
|
|
TypesQueryImplementationVersion(TPI* ptpi)
|
|
{
|
|
return ptpi->QueryImplementationVersion();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesQueryTiForCVRecord(TPI* ptpi, PB pb, OUT TI* pti)
|
|
{
|
|
return ptpi->QueryTiForCVRecord(pb, pti);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesQueryCVRecordForTi(TPI* ptpi, TI ti, OUT PB pb, IN OUT CB* pcb)
|
|
{
|
|
return ptpi->QueryCVRecordForTi(ti, pb, pcb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesQueryPbCVRecordForTi(TPI* ptpi, TI ti, OUT PB* ppb)
|
|
{
|
|
return ptpi->QueryPbCVRecordForTi(ti, ppb);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(TI)
|
|
TypesQueryTiMin(TPI* ptpi)
|
|
{
|
|
return ptpi->QueryTiMin();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(TI)
|
|
TypesQueryTiMac(TPI* ptpi)
|
|
{
|
|
return ptpi->QueryTiMac();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(CB)
|
|
TypesQueryCb(TPI* ptpi)
|
|
{
|
|
return ptpi->QueryCb();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesClose(TPI* ptpi)
|
|
{
|
|
return ptpi->Close();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesCommit(TPI* ptpi)
|
|
{
|
|
return ptpi->Commit();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesSupportQueryTiForUDT(TPI* ptpi)
|
|
{
|
|
return ptpi->SupportQueryTiForUDT();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
TypesQueryTiForUDT(TPI* ptpi, SZ sz, BOOL fCase, OUT TI* pti)
|
|
{
|
|
return ptpi->QueryTiForUDT(sz, fCase, pti);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(PB)
|
|
GSINextSym (GSI* pgsi, PB pbSym)
|
|
{
|
|
return pgsi->NextSym(pbSym);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(PB)
|
|
GSIHashSym (GSI* pgsi, SZ_CONST szName, PB pbSym)
|
|
{
|
|
return pgsi->HashSym (szName, pbSym);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(PB)
|
|
GSINearestSym (GSI* pgsi, ISECT isect, OFF off,OUT OFF* pdisp)
|
|
{
|
|
return pgsi->NearestSym (isect, off, pdisp);
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
GSIClose(GSI* pgsi)
|
|
{
|
|
return pgsi->Close();
|
|
}
|
|
|
|
};
|
|
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
EnumContribRelease(EnumContrib* penum)
|
|
{
|
|
penum->release();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
EnumContribReset(EnumContrib* penum)
|
|
{
|
|
penum->reset();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(BOOL)
|
|
EnumContribNext(EnumContrib* penum)
|
|
{
|
|
return penum->next();
|
|
}
|
|
|
|
PDB_IMPORT_EXPORT(void)
|
|
EnumContribGet(EnumContrib* penum, OUT USHORT* pimod, OUT USHORT* pisect, OUT long* poff, OUT long* pcb, OUT ULONG* pdwCharacteristics)
|
|
{
|
|
penum->get(pimod, pisect, poff, pcb, pdwCharacteristics);
|
|
}
|