Functions

Classes

Function addSynSymbol

addSynSymbol( (object)arg1, (object)arg2, (str)arg3) -> None :
Add new synthetic symbol for virtual address

C++ signature :
void addSynSymbol(unsigned __int64,unsigned long,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Function addr64

addr64( (object)arg1) -> int :
Extend address to 64 bits formats

C++ signature :
unsigned __int64 addr64(unsigned __int64)

Function attachKernel

attachKernel( (unicode)arg1) -> None :
Attach debugger to a kernel target

C++ signature :
void attachKernel(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function attachProcess

attachProcess( (object)arg1) -> None :
Attach debugger to a exsisting process

C++ signature :
void attachProcess(unsigned long)

Function breakin

breakin() -> None :
Break into debugger

C++ signature :
void breakin()

Function compareMemory

compareMemory( (object)offset1, (object)offset2, (object)length [, (bool)phyAddr]) -> bool :
Compare two memory buffers by virtual or physical addresses

C++ signature :
bool compareMemory(unsigned __int64,unsigned __int64,unsigned long [,bool])

Function containingRecord

containingRecord( (object)arg1, (str)arg2, (str)arg3) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

containingRecord( (object)arg1, (typeInfo)arg2, (str)arg3) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Function createDbgClient

createDbgClient() -> dbgClient :
create a new instance of the dbgClient class

C++ signature :
class boost::shared_ptr<class pykd::DebugClient> createDbgClient()

Function dbgCommand

dbgCommand( (unicode)arg1) -> str :
Run a debugger's command and return it's result as a string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > dbgCommand(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function debuggerPath

debuggerPath() -> str :
Return full path to the process image that uses pykd

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > debuggerPath()

Function delAllSynSymbols

delAllSynSymbols() -> None :
Delete all synthetic symbol for all modules

C++ signature :
void delAllSynSymbols()

Function delSynSymbol

delSynSymbol( (object)arg1) -> int :
Delete synthetic symbols by virtual address

C++ signature :
unsigned long delSynSymbol(unsigned __int64)

Function delSynSymbolsMask

delSynSymbolsMask( (str)arg1, (str)arg2) -> int :
Delete synthetic symbols by mask of module and symbol name

C++ signature :
unsigned long delSynSymbolsMask(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Function detachProcess

detachProcess() -> None :
Detach denugger from the current process

C++ signature :
void detachProcess()

Function diaLoadExe

diaLoadExe( (str)fileName [, (str)searchPath]) -> DiaScope :
Load the debug symbols associated with the executable file. Return DiaSymbol of global scope

C++ signature :
class boost::shared_ptr<class pyDia::GlobalScope> diaLoadExe(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > [,char const * __ptr64])

Function diaLoadPdb

diaLoadPdb( (str)arg1) -> DiaScope :
Open pdb file for querying debug symbols. Return DiaSymbol of global scope

C++ signature :
class boost::shared_ptr<class pyDia::GlobalScope> diaLoadPdb(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Function dprint

dprint( (unicode)str [, (bool)dml]) -> None :
Print out string. If dml = True string is printed with dml highlighting ( only for windbg )

C++ signature :
void dprint(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > [,bool])

Function dprintln

dprintln( (unicode)str [, (bool)dml]) -> None :
Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )

C++ signature :
void dprintln(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > [,bool])

Function expr

expr( (unicode)arg1) -> int :
Evaluate windbg expression

C++ signature :
unsigned __int64 expr(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function findSymbol

findSymbol( (object)arg1) -> str :
Find symbol by the target virtual memory offset

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > findSymbol(unsigned __int64)

Function getAllBp

getAllBp() -> list :
Get all breapoint IDs

C++ signature :
class boost::python::list getAllBp()

Function getContext

getContext() -> Context :
Get context of current thread (register values)

C++ signature :
class boost::shared_ptr<class pykd::ThreadContext> getContext()

Function getCurrentProcess

getCurrentProcess() -> int :
Return pointer to current process's block

C++ signature :
unsigned __int64 getCurrentProcess()

Function getCurrentStack

getCurrentStack() -> list :
Return a current stack as a list of stackFrame objects

C++ signature :
class boost::python::list getCurrentStack()

Function getDebuggeeType

getDebuggeeType() -> tuple :
Return type of the debuggee

C++ signature :
class boost::python::tuple getDebuggeeType()

Function getExecutionStatus

getExecutionStatus() -> int :
Return information about the execution status of the debugger

C++ signature :
unsigned long getExecutionStatus()

Function getImplicitThread

getImplicitThread() -> int :
Return implicit thread for current process

C++ signature :
unsigned __int64 getImplicitThread()

Function getLocals

getLocals([ (Context)ctx]) -> dict :
Get list of local variables

C++ signature :
class boost::python::dict getLocals([ class boost::shared_ptr<class pykd::ThreadContext>])

Function getNumberProcessors

getNumberProcessors() -> int :
Get the number of actual processors in the machine

C++ signature :
unsigned long getNumberProcessors()

Function getOffset

getOffset( (unicode)arg1) -> int :
Return traget virtual address for specified symbol

C++ signature :
unsigned __int64 getOffset(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function getPageSize

getPageSize() -> int :
Get the page size for the currently executing processor context

C++ signature :
unsigned long getPageSize()

Function getPdbFile

getPdbFile( (object)arg1) -> str :
Return full path to PDB (Program DataBase, debug information) file

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getPdbFile(unsigned __int64)

Function getProcessorMode

getProcessorMode() -> str :
Return current processor mode as string: X86, ARM, IA64 or X64

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getProcessorMode()

Function getProcessorType

getProcessorType() -> str :
Return type of physical processor: X86, ARM, IA64 or X64

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getProcessorType()

Function getThreadList

getThreadList() -> list :
Return list of threads (each item is numeric identifier of thread)

C++ signature :
class boost::python::list getThreadList()

Function go

go() -> None :
Change debugger status to DEBUG_STATUS_GO

C++ signature :
void go()

Function is64bitSystem

is64bitSystem() -> bool :
Check if target system has 64 address space

C++ signature :
bool is64bitSystem()

Function isDumpAnalyzing

isDumpAnalyzing() -> bool :
Check if it is a dump analyzing ( not living debuggee )

C++ signature :
bool isDumpAnalyzing()

Function isKernelDebugging

isKernelDebugging() -> bool :
Check if kernel dubugging is running

C++ signature :
bool isKernelDebugging()

Function isValid

isValid( (object)arg1) -> bool :
Check if the virtual address is valid

C++ signature :
bool isValid(unsigned __int64)

Function isWindbgExt

isWindbgExt() -> bool :
Check if script works in windbg context

C++ signature :
bool isWindbgExt()

Function killProcess

killProcess() -> None :
Stop debugging and terminate current process

C++ signature :
void killProcess()

Function loadAnsiString

loadAnsiString( (object)arg1) -> str :
Return string represention of windows ANSU_STRING type

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadAnsiString(unsigned __int64)

Function loadBytes

loadBytes( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as liat of unsigned bytes

C++ signature :
class boost::python::list loadBytes(unsigned __int64,unsigned long [,bool])

Function loadCStr

loadCStr( (object)arg1) -> str :
Load string from the target buffer containing 0-terminated ansi-string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadCStr(unsigned __int64)

Function loadChars

loadChars( (object)address, (object)count [, (bool)phyAddr]) -> str :
Load string from target memory

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadChars(unsigned __int64,unsigned long [,bool])

Function loadDWords

loadDWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned long ( double word )

C++ signature :
class boost::python::list loadDWords(unsigned __int64,unsigned long [,bool])

Function loadDump

loadDump( (unicode)arg1) -> None :
Load crash dump (only for console)

C++ signature :
void loadDump(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function loadExt

loadExt( (unicode)arg1) -> ext :
Load a debuger extension

C++ signature :
class boost::shared_ptr<class pykd::DbgExtension> loadExt(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function loadModule

loadModule( (str)arg1) -> module :
Return instance of Module class

C++ signature :
class boost::shared_ptr<class pykd::Module> loadModule(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

loadModule( (object)arg1) -> module :
Return instance of the Module class which posseses specified address

C++ signature :
class boost::shared_ptr<class pykd::Module> loadModule(unsigned __int64)

Function loadPtrList

loadPtrList( (object)arg1) -> list :
Return list of pointers, each points to next

C++ signature :
class boost::python::list loadPtrList(unsigned __int64)

Function loadPtrs

loadPtrs( (object)arg1, (object)arg2) -> list :
Read the block of the target's memory and return it as a list of pointers

C++ signature :
class boost::python::list loadPtrs(unsigned __int64,unsigned long)

Function loadQWords

loadQWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned long long ( quad word )

C++ signature :
class boost::python::list loadQWords(unsigned __int64,unsigned long [,bool])

Function loadSignBytes

loadSignBytes( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed bytes

C++ signature :
class boost::python::list loadSignBytes(unsigned __int64,unsigned long [,bool])

Function loadSignDWords

loadSignDWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed longs

C++ signature :
class boost::python::list loadSignDWords(unsigned __int64,unsigned long [,bool])

Function loadSignQWords

loadSignQWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed long longs

C++ signature :
class boost::python::list loadSignQWords(unsigned __int64,unsigned long [,bool])

Function loadSignWords

loadSignWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed words

C++ signature :
class boost::python::list loadSignWords(unsigned __int64,unsigned long [,bool])

Function loadUnicodeString

loadUnicodeString( (object)arg1) -> unicode :
Return string represention of windows UNICODE_STRING type

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadUnicodeString(unsigned __int64)

Function loadWChars

loadWChars( (object)address, (object)count [, (bool)phyAddr]) -> unicode :
Load string from target memory

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadWChars(unsigned __int64,unsigned long [,bool])

Function loadWStr

loadWStr( (object)arg1) -> unicode :
Load string from the target buffer containing 0-terminated unicode-string

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadWStr(unsigned __int64)

Function loadWords

loadWords( (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned shorts

C++ signature :
class boost::python::list loadWords(unsigned __int64,unsigned long [,bool])

Function ptrByte

ptrByte( (object)arg1) -> int :
Read an unsigned 1-byte integer from the target memory

C++ signature :
unsigned __int64 ptrByte(unsigned __int64)

Function ptrDWord

ptrDWord( (object)arg1) -> int :
Read an unsigned 4-byte integer from the target memory

C++ signature :
unsigned __int64 ptrDWord(unsigned __int64)

Function ptrMWord

ptrMWord( (object)arg1) -> int :
Read an unsigned mashine's word wide integer from the target memory

C++ signature :
unsigned __int64 ptrMWord(unsigned __int64)

Function ptrPtr

ptrPtr( (object)arg1) -> int :
Read an pointer value from the target memory

C++ signature :
unsigned __int64 ptrPtr(unsigned __int64)

Function ptrQWord

ptrQWord( (object)arg1) -> int :
Read an unsigned 8-byte integer from the target memory

C++ signature :
unsigned __int64 ptrQWord(unsigned __int64)

Function ptrSignByte

ptrSignByte( (object)arg1) -> int :
Read an signed 1-byte integer from the target memory

C++ signature :
__int64 ptrSignByte(unsigned __int64)

Function ptrSignDWord

ptrSignDWord( (object)arg1) -> int :
Read an signed 4-byte integer from the target memory

C++ signature :
__int64 ptrSignDWord(unsigned __int64)

Function ptrSignMWord

ptrSignMWord( (object)arg1) -> int :
Read an signed mashine's word wide integer from the target memory

C++ signature :
__int64 ptrSignMWord(unsigned __int64)

Function ptrSignQWord

ptrSignQWord( (object)arg1) -> int :
Read an signed 8-byte integer from the target memory

C++ signature :
__int64 ptrSignQWord(unsigned __int64)

Function ptrSignWord

ptrSignWord( (object)arg1) -> int :
Read an signed 2-byte integer from the target memory

C++ signature :
__int64 ptrSignWord(unsigned __int64)

Function ptrSize

ptrSize() -> int :
Return effective pointer size

C++ signature :
unsigned long ptrSize()

Function ptrWord

ptrWord( (object)arg1) -> int :
Read an unsigned 2-byte integer from the target memory

C++ signature :
unsigned __int64 ptrWord(unsigned __int64)

Function rdmsr

rdmsr( (object)arg1) -> int :
Return MSR value

C++ signature :
unsigned __int64 rdmsr(unsigned long)

Function reg

reg( (str)arg1) -> cpuReg :
Return a CPU regsiter value by the register's name

C++ signature :
class pykd::CpuReg reg(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

reg( (object)arg1) -> cpuReg :
Return a CPU regsiter value by the register's value

C++ signature :
class pykd::CpuReg reg(unsigned long)

Function removeBp

removeBp( (object)arg1) -> None :
Remove breapoint by IDs

C++ signature :
void removeBp(unsigned long)

removeBp() -> None :
Remove all breapoints

C++ signature :
void removeBp()

Function setBp

setBp( (object)offset [, (object)callback]) -> int :
Set software breakpoint on executiont

C++ signature :
unsigned long setBp(unsigned __int64 [,class boost::python::api::object {lvalue}])

setBp( (object)offset, (object)size, (object)accsessType [, (object)callback]) -> int :
Set hardware breakpoint

C++ signature :
unsigned long setBp(unsigned __int64,unsigned long,unsigned long [,class boost::python::api::object {lvalue}])

Function setCurrentProcess

setCurrentProcess( (object)arg1) -> None :
Set current process by address

C++ signature :
void setCurrentProcess(unsigned __int64)

Function setExecutionStatus

setExecutionStatus( (object)arg1) -> None :
Requests that the debugger engine enter an executable state

C++ signature :
void setExecutionStatus(unsigned long)

Function setImplicitThread

setImplicitThread( (object)arg1) -> None :
Set implicit thread for current process

C++ signature :
void setImplicitThread(unsigned __int64)

Function setProcessorMode

setProcessorMode( (unicode)arg1) -> None :
Set current processor mode by string (X86, ARM, IA64 or X64)

C++ signature :
void setProcessorMode(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function startProcess

startProcess( (unicode)arg1) -> None :
Start process for debugging (only for console)

C++ signature :
void startProcess(class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Function step

step() -> None :
Change debugger status to DEBUG_STATUS_STEP_OVER

C++ signature :
void step()

Function symbolsPath

symbolsPath() -> str :
Return symbol path

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > symbolsPath()

Function trace

trace() -> None :
Change debugger status to DEBUG_STATUS_STEP_INTO

C++ signature :
void trace()

Function typedVarArray

typedVarArray( (object)arg1, (str)arg2, (object)arg3) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned long)

typedVarArray( (object)arg1, (typeInfo)arg2, (object)arg3) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,unsigned long)

Function typedVarList

typedVarList( (object)arg1, (str)arg2, (str)arg3) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVarList( (object)arg1, (typeInfo)arg2, (str)arg3) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Function waitForEvent

waitForEvent() -> None :
Wait for events that breaks into the debugger

C++ signature :
void waitForEvent()

Function wrmsr

wrmsr( (object)arg1, (object)arg2) -> None :
Set MSR value

C++ signature :
void wrmsr(unsigned long,unsigned __int64)

Class Context

Context of thread (register values)

Context.__getitem__

__getitem__( (Context)arg1, (object)arg2) -> object :
Return tuple<ID, VALUE> by index

C++ signature :
class boost::python::api::object __getitem__(class pykd::ThreadContext {lvalue},unsigned long)

Context.__len__

__len__( (Context)arg1) -> int :
Return count of registers

C++ signature :
unsigned long __len__(class pykd::ThreadContext {lvalue})

Context.csp

csp( (Context)arg1) -> int :
Get current stack pointer

C++ signature :
unsigned __int64 csp(class pykd::ThreadContext {lvalue})

Context.fork

fork( (Context)arg1, (stackFrame)arg2) -> Context :
Create new thread context by stackFrame

C++ signature :
class boost::shared_ptr<class pykd::ThreadContext> fork(class pykd::ThreadContext {lvalue},class pykd::StackFrame)

Context.get

get( (Context)arg1, (object)arg2) -> int :
Get register value by ID (CV_REG_XXX)

C++ signature :
unsigned __int64 get(class pykd::ThreadContext {lvalue},unsigned long)

Context.ip

ip( (Context)arg1) -> int :
Get instruction pointer register

C++ signature :
unsigned __int64 ip(class pykd::ThreadContext {lvalue})

Context.processorType

processorType( (Context)arg1) -> str :
Get processor ThreadContext as string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > processorType(class pykd::ThreadContext {lvalue})

Context.retreg

retreg( (Context)arg1) -> int :
Get primary return value register

C++ signature :
unsigned __int64 retreg(class pykd::ThreadContext {lvalue})

Class DiaScope

class wrapper for MS DIA global scope

DiaScope.findByRva

findByRva( (DiaScope)arg1, (object)arg2, (object)arg3) -> tuple :
Find symbol by RVA. Return tuple: (DiaSymbol, offset)

C++ signature :
class boost::python::tuple findByRva(class pyDia::GlobalScope {lvalue},unsigned long,unsigned long)

DiaScope.findByVa

findByVa( (DiaScope)arg1, (object)arg2, (object)arg3) -> tuple :
Find symbol by VA. Return tuple: (DiaSymbol, offset)

C++ signature :
class boost::python::tuple findByVa(class pyDia::GlobalScope {lvalue},unsigned long,unsigned long)

DiaScope.loadAddress

loadAddress( (DiaScope)arg1) -> int :
Retrieves the load address for the executable file that corresponds to the symbols in this symbol store

C++ signature :
unsigned __int64 loadAddress(class pyDia::GlobalScope {lvalue})

DiaScope.setLoadAddress

setLoadAddress( (DiaScope)arg1, (object)arg2) -> None :
Sets the load address for the executable file that corresponds to the symbols in this symbol store

C++ signature :
void setLoadAddress(class pyDia::GlobalScope {lvalue},unsigned __int64)

DiaScope.symbolById

symbolById( (DiaScope)arg1, (object)arg2) -> DiaSymbol :
Retrieves a symbol by its unique identifier: DiaSymbol::indexId()

C++ signature :
class boost::shared_ptr<class pyDia::Symbol> symbolById(class pyDia::GlobalScope {lvalue},unsigned long)

Class DiaSymbol

class wrapper for MS DIA Symbol

DiaSymbol.__eq__

__eq__( (DiaSymbol)arg1, (DiaSymbol)arg2) -> bool :

C++ signature :
bool __eq__(class pyDia::Symbol {lvalue},class pyDia::Symbol {lvalue})

DiaSymbol.__getitem__

__getitem__( (DiaSymbol)arg1, (str)arg2) -> DiaSymbol :

C++ signature :
class boost::shared_ptr<class pyDia::Symbol> __getitem__(class pyDia::Symbol {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

__getitem__( (DiaSymbol)arg1, (object)arg2) -> DiaSymbol :

C++ signature :
class boost::shared_ptr<class pyDia::Symbol> __getitem__(class pyDia::Symbol {lvalue},unsigned long)

DiaSymbol.__hash__

__hash__( (DiaSymbol)arg1) -> int :

C++ signature :
unsigned long __hash__(class pyDia::Symbol {lvalue})

DiaSymbol.__len__

__len__( (DiaSymbol)arg1) -> int :

C++ signature :
unsigned long __len__(class pyDia::Symbol {lvalue})

DiaSymbol.__str__

__str__( (DiaSymbol)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pyDia::Symbol {lvalue})

DiaSymbol.baseType

baseType( (DiaSymbol)arg1) -> int :
Retrieves the base type for this symbol

C++ signature :
unsigned long baseType(class pyDia::Symbol {lvalue})

DiaSymbol.bitPos

bitPos( (DiaSymbol)arg1) -> int :
Retrieves the base type for this symbol

C++ signature :
unsigned long bitPos(class pyDia::Symbol {lvalue})

DiaSymbol.count

count( (DiaSymbol)arg1) -> int :
Retrieves the number of items in a list or array

C++ signature :
unsigned long count(class pyDia::Symbol {lvalue})

DiaSymbol.dataKind

dataKind( (DiaSymbol)arg1) -> int :
Retrieves the variable classification of a data symbol

C++ signature :
unsigned long dataKind(class pyDia::Symbol {lvalue})

DiaSymbol.find

find( (DiaSymbol)arg1, (str)arg2) -> list :
Retrieves the children of the symbol

C++ signature :
class boost::python::list find(class pyDia::Symbol {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

DiaSymbol.findEx

findEx( (DiaSymbol)arg1, (object)symTag [, (str)name [, (object)cmpFlags]]) -> list :
Retrieves the children of the symbol

C++ signature :
class boost::python::list findEx(class pyDia::Symbol {lvalue},unsigned long [,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > [,unsigned long]])

DiaSymbol.indexId

indexId( (DiaSymbol)arg1) -> int :
Retrieves the unique symbol identifier

C++ signature :
unsigned long indexId(class pyDia::Symbol {lvalue})

DiaSymbol.indexType

indexType( (DiaSymbol)arg1) -> DiaSymbol :
Retrieves a reference to the class parent of the symbol

C++ signature :
class boost::shared_ptr<class pyDia::Symbol> indexType(class pyDia::Symbol {lvalue})

DiaSymbol.isBasic

isBasic( (DiaSymbol)arg1) -> bool :
Retrieves a flag of basic type for symbol

C++ signature :
bool isBasic(class pyDia::Symbol {lvalue})

DiaSymbol.locType

locType( (DiaSymbol)arg1) -> int :
Retrieves the location type of a data symbol: LocIsXxx

C++ signature :
unsigned long locType(class pyDia::Symbol {lvalue})

DiaSymbol.machineType

machineType( (DiaSymbol)arg1) -> int :
Retrieves the type of the target CPU: IMAGE_FILE_MACHINE_XXX

C++ signature :
unsigned long machineType(class pyDia::Symbol {lvalue})

DiaSymbol.name

name( (DiaSymbol)arg1) -> str :
Retrieves the name of the symbol

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > name(class pyDia::Symbol {lvalue})

DiaSymbol.offset

offset( (DiaSymbol)arg1) -> int :
Retrieves the offset of the symbol location

C++ signature :
long offset(class pyDia::Symbol {lvalue})

DiaSymbol.registerId

registerId( (DiaSymbol)arg1) -> int :
Retrieves the register designator of the location:
CV_REG_XXX (for IMAGE_FILE_MACHINE_I386) or CV_AMD64_XXX (for IMAGE_FILE_MACHINE_AMD64)

C++ signature :
unsigned long registerId(class pyDia::Symbol {lvalue})

DiaSymbol.rva

rva( (DiaSymbol)arg1) -> int :
Retrieves the relative virtual address (RVA) of the location

C++ signature :
unsigned long rva(class pyDia::Symbol {lvalue})

DiaSymbol.size

size( (DiaSymbol)arg1) -> int :
Retrieves the number of bits or bytes of memory used by the object represented by this symbol

C++ signature :
unsigned __int64 size(class pyDia::Symbol {lvalue})

DiaSymbol.symTag

symTag( (DiaSymbol)arg1) -> int :
Retrieves the symbol type classifier: SymTagXxx

C++ signature :
unsigned long symTag(class pyDia::Symbol {lvalue})

DiaSymbol.type

type( (DiaSymbol)arg1) -> DiaSymbol :
Retrieves the symbol that represents the type for this symbol

C++ signature :
class boost::shared_ptr<class pyDia::Symbol> type(class pyDia::Symbol {lvalue})

DiaSymbol.udtKind

udtKind( (DiaSymbol)arg1) -> int :
Retrieves the variety of a user-defined type

C++ signature :
unsigned long udtKind(class pyDia::Symbol {lvalue})

DiaSymbol.undecoratedName

undecoratedName( (DiaSymbol)arg1) -> str :
Retrieves the undecorated name for a C++ decorated, or linkage, name

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > undecoratedName(class pyDia::Symbol {lvalue})

DiaSymbol.va

va( (DiaSymbol)arg1) -> int :
Retrieves the virtual address (VA) of the location

C++ signature :
unsigned __int64 va(class pyDia::Symbol {lvalue})

DiaSymbol.value

value( (DiaSymbol)arg1) -> object :
Retrieves the value of a constant

C++ signature :
class boost::python::api::object value(class pyDia::Symbol {lvalue})

Class cpuReg

CPU regsiter class

cpuReg.index

index( (cpuReg)arg1) -> int :
The index of thr register

C++ signature :
unsigned long index(class pykd::CpuReg {lvalue})

cpuReg.name

name( (cpuReg)arg1) -> str :
The name of the regsiter

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > name(class pykd::CpuReg {lvalue})

Class dbgClient

Class representing a debugging session

dbgClient.addSynSymbol

addSynSymbol( (dbgClient)arg1, (object)arg2, (object)arg3, (str)arg4) -> None :
Add new synthetic symbol for virtual address

C++ signature :
void addSynSymbol(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

dbgClient.addr64

addr64( (dbgClient)arg1, (object)arg2) -> int :
Extend address to 64 bits formats

C++ signature :
unsigned __int64 addr64(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.attachKernel

attachKernel( (dbgClient)arg1, (unicode)arg2) -> None :
Attach debugger to a target's kernel

C++ signature :
void attachKernel(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.attachProcess

attachProcess( (dbgClient)arg1, (object)arg2) -> None :
Attach debugger to a exsisting process

C++ signature :
void attachProcess(class pykd::DebugClient {lvalue},unsigned long)

dbgClient.breakin

breakin( (dbgClient)arg1) -> None :
Break into debugger

C++ signature :
void breakin(class pykd::DebugClient {lvalue})

dbgClient.compareMemory

compareMemory( (dbgClient)arg1, (object)offset1, (object)offset2, (object)length [, (bool)phyAddr]) -> bool :
Compare two memory buffers by virtual or physical addresses

C++ signature :
bool compareMemory(class pykd::DebugClient {lvalue},unsigned __int64,unsigned __int64,unsigned long [,bool])

dbgClient.containingRecord

containingRecord( (dbgClient)arg1, (object)arg2, (str)arg3, (str)arg4) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(class pykd::DebugClient {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

containingRecord( (dbgClient)arg1, (object)arg2, (typeInfo)arg3, (str)arg4) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(class pykd::DebugClient {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

dbgClient.dbgCommand

dbgCommand( (dbgClient)arg1, (unicode)arg2) -> str :
Run a debugger's command and return it's result as a string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > dbgCommand(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.delAllSynSymbols

delAllSynSymbols( (dbgClient)arg1) -> None :
Delete all synthetic symbol for all modules

C++ signature :
void delAllSynSymbols(class pykd::DebugClient {lvalue})

dbgClient.delSynSymbol

delSynSymbol( (dbgClient)arg1, (object)arg2) -> int :
Delete synthetic symbols by virtual address

C++ signature :
unsigned long delSynSymbol(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.delSynSymbolsMask

delSynSymbolsMask( (dbgClient)arg1, (str)arg2, (str)arg3) -> int :
Delete synthetic symbols by mask of module and symbol name

C++ signature :
unsigned long delSynSymbolsMask(class pykd::DebugClient {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

dbgClient.detachProcess

detachProcess( (dbgClient)arg1) -> None :
Detach debugger from the current process

C++ signature :
void detachProcess(class pykd::DebugClient {lvalue})

dbgClient.dprint

dprint( (dbgClient)arg1, (unicode)arg2, (bool)arg3) -> None :
Print out string. If dml = True string is printed with dml highlighting ( only for windbg )

C++ signature :
void dprint(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >,bool)

dbgClient.dprintln

dprintln( (dbgClient)arg1, (unicode)arg2, (bool)arg3) -> None :
Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )

C++ signature :
void dprintln(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >,bool)

dbgClient.expr

expr( (dbgClient)arg1, (unicode)arg2) -> int :
Evaluate windbg expression

C++ signature :
unsigned __int64 expr(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.findSymbol

findSymbol( (dbgClient)arg1, (object)arg2) -> str :
Find symbol by the target virtual memory offset

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > findSymbol(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.getAllBp

getAllBp( (dbgClient)arg1) -> list :
Get all breapoint IDs

C++ signature :
class boost::python::list getAllBp(class pykd::DebugClient {lvalue})

dbgClient.getContext

getContext( (dbgClient)arg1) -> Context :
Get context of current thread (register values)

C++ signature :
class boost::shared_ptr<class pykd::ThreadContext> getContext(class pykd::DebugClient {lvalue})

dbgClient.getCurrentProcess

getCurrentProcess( (dbgClient)arg1) -> int :
Return pointer to current process's block

C++ signature :
unsigned __int64 getCurrentProcess(class pykd::DebugClient {lvalue})

dbgClient.getCurrentStack

getCurrentStack( (dbgClient)arg1) -> list :
Return a current stack as a list of stackFrame objects

C++ signature :
class boost::python::list getCurrentStack(class pykd::DebugClient {lvalue})

dbgClient.getDebuggeeType

getDebuggeeType( (dbgClient)arg1) -> tuple :
Return type of the debuggee

C++ signature :
class boost::python::tuple getDebuggeeType(class pykd::DebugClient {lvalue})

dbgClient.getExecutionStatus

getExecutionStatus( (dbgClient)arg1) -> int :
Return information about the execution status of the debugger

C++ signature :
unsigned long getExecutionStatus(class pykd::DebugClient {lvalue})

dbgClient.getImplicitThread

getImplicitThread( (dbgClient)arg1) -> int :
Return implicit thread for current process

C++ signature :
unsigned __int64 getImplicitThread(class pykd::DebugClient {lvalue})

dbgClient.getLocals

getLocals( (dbgClient)arg1 [, (Context)ctx]) -> dict :
Get list of local variables

C++ signature :
class boost::python::dict getLocals(class pykd::DebugClient {lvalue} [,class boost::shared_ptr<class pykd::ThreadContext>])

dbgClient.getNumberProcessors

getNumberProcessors( (dbgClient)arg1) -> int :
Get the number of actual processors in the machine

C++ signature :
unsigned long getNumberProcessors(class pykd::DebugClient {lvalue})

dbgClient.getOffset

getOffset( (dbgClient)arg1, (unicode)arg2) -> int :
Return traget virtual address for specified symbol

C++ signature :
unsigned __int64 getOffset(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.getPageSize

getPageSize( (dbgClient)arg1) -> int :
Get the page size for the currently executing processor context

C++ signature :
unsigned long getPageSize(class pykd::DebugClient {lvalue})

dbgClient.getPdbFile

getPdbFile( (dbgClient)arg1, (object)arg2) -> str :
Return full path to PDB (Program DataBase, debug information) file

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getPdbFile(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.getProcessorMode

getProcessorMode( (dbgClient)arg1) -> str :
Return current processor mode as string: X86, ARM, IA64 or X64

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getProcessorMode(class pykd::DebugClient {lvalue})

dbgClient.getProcessorType

getProcessorType( (dbgClient)arg1) -> str :
Return type of physical processor: X86, ARM, IA64 or X64

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > getProcessorType(class pykd::DebugClient {lvalue})

dbgClient.getThreadList

getThreadList( (dbgClient)arg1) -> list :
Return list of threads (each item is numeric identifier of thread)

C++ signature :
class boost::python::list getThreadList(class pykd::DebugClient {lvalue})

dbgClient.go

go( (dbgClient)arg1) -> None :
Change debugger status to DEBUG_STATUS_GO

C++ signature :
void go(class pykd::DebugClient {lvalue})

dbgClient.is64bitSystem

is64bitSystem( (dbgClient)arg1) -> bool :
Check if target system has 64 address space

C++ signature :
bool is64bitSystem(class pykd::DebugClient {lvalue})

dbgClient.isDumpAnalyzing

isDumpAnalyzing( (dbgClient)arg1) -> bool :
Check if it is a dump analyzing ( not living debuggee )

C++ signature :
bool isDumpAnalyzing(class pykd::DebugClient {lvalue})

dbgClient.isKernelDebugging

isKernelDebugging( (dbgClient)arg1) -> bool :
Check if kernel dubugging is running

C++ signature :
bool isKernelDebugging(class pykd::DebugClient {lvalue})

dbgClient.isValid

isValid( (dbgClient)arg1, (object)arg2) -> bool :
Check if the virtual address is valid

C++ signature :
bool isValid(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.killProcess

killProcess( (dbgClient)arg1) -> None :
Stop debugging and terminate current process

C++ signature :
void killProcess(class pykd::DebugClient {lvalue})

dbgClient.loadAnsiString

loadAnsiString( (dbgClient)arg1, (object)arg2) -> str :
Return string represention of windows ANSI_STRING type

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadAnsiString(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadBytes

loadBytes( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned bytes

C++ signature :
class boost::python::list loadBytes(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadCStr

loadCStr( (dbgClient)arg1, (object)arg2) -> str :
Load string from the target buffer containing 0-terminated ansi-string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadCStr(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadChars

loadChars( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> str :
Load string from target memory

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > loadChars(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadDWords

loadDWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned long ( double word )

C++ signature :
class boost::python::list loadDWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadDump

loadDump( (dbgClient)arg1, (unicode)arg2) -> None :
Load crash dump

C++ signature :
void loadDump(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.loadExt

loadExt( (dbgClient)arg1, (unicode)arg2) -> ext :
Load a debuger extension

C++ signature :
class boost::shared_ptr<class pykd::DbgExtension> loadExt(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.loadModule

loadModule( (dbgClient)arg1, (str)arg2) -> module :
Return instance of Module class

C++ signature :
class boost::shared_ptr<class pykd::Module> loadModule(class pykd::DebugClient {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

loadModule( (dbgClient)arg1, (object)arg2) -> module :
Return instance of the Module class which posseses specified address

C++ signature :
class boost::shared_ptr<class pykd::Module> loadModule(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadPtrList

loadPtrList( (dbgClient)arg1, (object)arg2) -> list :
Return list of pointers, each points to next

C++ signature :
class boost::python::list loadPtrList(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadPtrs

loadPtrs( (dbgClient)arg1, (object)arg2, (object)arg3) -> list :
Read the block of the target's memory and return it as a list of pointers

C++ signature :
class boost::python::list loadPtrs(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long)

dbgClient.loadQWords

loadQWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned long long ( quad word )

C++ signature :
class boost::python::list loadQWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadSignBytes

loadSignBytes( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed bytes

C++ signature :
class boost::python::list loadSignBytes(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadSignDWords

loadSignDWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed longs

C++ signature :
class boost::python::list loadSignDWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadSignQWords

loadSignQWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed long longs

C++ signature :
class boost::python::list loadSignQWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadSignWords

loadSignWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of signed shorts

C++ signature :
class boost::python::list loadSignWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadUnicodeString

loadUnicodeString( (dbgClient)arg1, (object)arg2) -> unicode :
Return string represention of windows UNICODE_STRING type

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadUnicodeString(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadWChars

loadWChars( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> unicode :
Load string from target memory

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadWChars(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.loadWStr

loadWStr( (dbgClient)arg1, (object)arg2) -> unicode :
Load string from the target buffer containing 0-terminated unicode-string

C++ signature :
class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> > loadWStr(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.loadWords

loadWords( (dbgClient)arg1, (object)offset, (object)count [, (bool)phyAddr]) -> list :
Read the block of the target's memory and return it as list of unsigned shorts

C++ signature :
class boost::python::list loadWords(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long [,bool])

dbgClient.ptrByte

ptrByte( (dbgClient)arg1, (object)arg2) -> int :
Read an unsigned 1-byte integer from the target memory

C++ signature :
unsigned __int64 ptrByte(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrDWord

ptrDWord( (dbgClient)arg1, (object)arg2) -> int :
Read an unsigned 4-byte integer from the target memory

C++ signature :
unsigned __int64 ptrDWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrMWord

ptrMWord( (dbgClient)arg1, (object)arg2) -> int :
Read an unsigned mashine's word wide integer from the target memory

C++ signature :
unsigned __int64 ptrMWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrPtr

ptrPtr( (dbgClient)arg1, (object)arg2) -> int :
Read an pointer value from the target memory

C++ signature :
unsigned __int64 ptrPtr(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrQWord

ptrQWord( (dbgClient)arg1, (object)arg2) -> int :
Read an unsigned 8-byte integer from the target memory

C++ signature :
unsigned __int64 ptrQWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSignByte

ptrSignByte( (dbgClient)arg1, (object)arg2) -> int :
Read an signed 1-byte integer from the target memory

C++ signature :
__int64 ptrSignByte(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSignDWord

ptrSignDWord( (dbgClient)arg1, (object)arg2) -> int :
Read an signed 4-byte integer from the target memory

C++ signature :
__int64 ptrSignDWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSignMWord

ptrSignMWord( (dbgClient)arg1, (object)arg2) -> int :
Read an signed mashine's word wide integer from the target memory

C++ signature :
__int64 ptrSignMWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSignQWord

ptrSignQWord( (dbgClient)arg1, (object)arg2) -> int :
Read an signed 8-byte integer from the target memory

C++ signature :
__int64 ptrSignQWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSignWord

ptrSignWord( (dbgClient)arg1, (object)arg2) -> int :
Read an signed 2-byte integer from the target memory

C++ signature :
__int64 ptrSignWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.ptrSize

ptrSize( (dbgClient)arg1) -> int :
Return effective pointer size

C++ signature :
unsigned long ptrSize(class pykd::DebugClient {lvalue})

dbgClient.ptrWord

ptrWord( (dbgClient)arg1, (object)arg2) -> int :
Read an unsigned 2-byte integer from the target memory

C++ signature :
unsigned __int64 ptrWord(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.rdmsr

rdmsr( (dbgClient)arg1, (object)arg2) -> int :
Return MSR value

C++ signature :
unsigned __int64 rdmsr(class pykd::DebugClient {lvalue},unsigned long)

dbgClient.reg

reg( (dbgClient)arg1, (str)arg2) -> cpuReg :
Return a CPU regsiter value by the register's name

C++ signature :
class pykd::CpuReg reg(class pykd::DebugClient {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

reg( (dbgClient)arg1, (object)arg2) -> cpuReg :
Return a CPU regsiter value by the register's value

C++ signature :
class pykd::CpuReg reg(class pykd::DebugClient {lvalue},unsigned long)

dbgClient.removeBp

removeBp( (dbgClient)arg1, (object)arg2) -> None :
Remove breapoint by IDs

C++ signature :
void removeBp(class pykd::DebugClient {lvalue},unsigned long)

removeBp( (dbgClient)arg1) -> None :
Remove all breapoints

C++ signature :
void removeBp(class pykd::DebugClient {lvalue})

dbgClient.setBp

setBp( (dbgClient)arg1, (object)offset [, (object)callback]) -> int :
Set software breakpoint on executiont

C++ signature :
unsigned long setBp(class pykd::DebugClient {lvalue},unsigned __int64 [,class boost::python::api::object {lvalue}])

setBp( (dbgClient)arg1, (object)offset, (object)size, (object)accsessType [, (object)callback]) -> int :
Set hardware breakpoint

C++ signature :
unsigned long setBp(class pykd::DebugClient {lvalue},unsigned __int64,unsigned long,unsigned long [,class boost::python::api::object {lvalue}])

dbgClient.setCurrentProcess

setCurrentProcess( (dbgClient)arg1, (object)arg2) -> None :
Set current process by address

C++ signature :
void setCurrentProcess(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.setExecutionStatus

setExecutionStatus( (dbgClient)arg1, (object)arg2) -> None :
Requests that the debugger engine enter an executable state

C++ signature :
void setExecutionStatus(class pykd::DebugClient {lvalue},unsigned long)

dbgClient.setImplicitThread

setImplicitThread( (dbgClient)arg1, (object)arg2) -> None :
Set implicit thread for current process

C++ signature :
void setImplicitThread(class pykd::DebugClient {lvalue},unsigned __int64)

dbgClient.setProcessorMode

setProcessorMode( (dbgClient)arg1, (unicode)arg2) -> None :
Set current processor mode by string (X86, ARM, IA64 or X64)

C++ signature :
void setProcessorMode(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.startProcess

startProcess( (dbgClient)arg1, (unicode)arg2) -> None :
Start process for debugging

C++ signature :
void startProcess(class pykd::DebugClient {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

dbgClient.step

step( (dbgClient)arg1) -> None :
Change debugger status to DEBUG_STATUS_STEP_OVER

C++ signature :
void step(class pykd::DebugClient {lvalue})

dbgClient.symbolsPath

symbolsPath( (dbgClient)arg1) -> str :
Return symbol path

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > symbolsPath(class pykd::DebugClient {lvalue})

dbgClient.trace

trace( (dbgClient)arg1) -> None :
Change debugger status to DEBUG_STATUS_STEP_INTO

C++ signature :
void trace(class pykd::DebugClient {lvalue})

dbgClient.typedVar

typedVar( (dbgClient)arg1, (str)arg2) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::DebugClient {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVar( (dbgClient)arg1, (typeInfo)arg2, (object)arg3) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::DebugClient {lvalue},class boost::shared_ptr<class pykd::TypeInfo>,unsigned __int64)

typedVar( (dbgClient)arg1, (str)arg2, (object)arg3) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::DebugClient {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned __int64)

dbgClient.typedVarArray

typedVarArray( (dbgClient)arg1, (object)arg2, (str)arg3, (object)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(class pykd::DebugClient {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned long)

typedVarArray( (dbgClient)arg1, (object)arg2, (typeInfo)arg3, (object)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(class pykd::DebugClient {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,unsigned long)

dbgClient.typedVarList

typedVarList( (dbgClient)arg1, (object)arg2, (str)arg3, (str)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(class pykd::DebugClient {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVarList( (dbgClient)arg1, (object)arg2, (typeInfo)arg3, (str)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(class pykd::DebugClient {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

dbgClient.waitForEvent

waitForEvent( (dbgClient)arg1) -> None :
Wait for events that breaks into the debugger

C++ signature :
void waitForEvent(class pykd::DebugClient {lvalue})

dbgClient.wrmsr

wrmsr( (dbgClient)arg1, (object)arg2, (object)arg3) -> None :
Set MSR value

C++ signature :
void wrmsr(class pykd::DebugClient {lvalue},unsigned long,unsigned __int64)

Class din

din

din.readline

readline( (din)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > readline(class pykd::DbgIn {lvalue})

Class disasm

Class disassemble a processor instructions

disasm.__init__

__init__( (object)arg1) -> None :

C++ signature :
void __init__(struct _object * __ptr64)

__init__( (object)arg1) -> None :
constructor

C++ signature :
void __init__(struct _object * __ptr64)

__init__( (object)arg1, (object)offset) -> None :
constructor

C++ signature :
void __init__(struct _object * __ptr64,unsigned __int64)

disasm.asm

asm( (disasm)arg1, (str)arg2) -> str :
Insert assemblied instuction to current offset

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > asm(class pykd::Disasm {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

disasm.begin

begin( (disasm)arg1) -> int :
Return begin offset

C++ signature :
unsigned __int64 begin(class pykd::Disasm {lvalue})

disasm.current

current( (disasm)arg1) -> int :
Return current offset

C++ signature :
unsigned __int64 current(class pykd::Disasm {lvalue})

disasm.disasm

disasm( (disasm)arg1) -> str :
Disassemble next instruction

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > disasm(class pykd::Disasm {lvalue})

disasm.ea

ea( (disasm)arg1) -> int :
Return effective address for last disassembled instruction or 0

C++ signature :
unsigned __int64 ea(class pykd::Disasm {lvalue})

disasm.instruction

instruction( (disasm)arg1) -> str :
Returm current disassembled instruction

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > instruction(class pykd::Disasm {lvalue})

disasm.length

length( (disasm)arg1) -> int :
Return current instruction length

C++ signature :
unsigned long length(class pykd::Disasm {lvalue})

disasm.reset

reset( (disasm)arg1) -> str :
Reset current offset to begin

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > reset(class pykd::Disasm {lvalue})

Class dout

dout

dout.write

write( (dout)arg1, (unicode)arg2) -> None :

C++ signature :
void write(class pykd::DbgOut {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Class eventHandler

Base class for overriding and handling debug notifications

eventHandler.__init__

__init__( (object)arg1) -> None :

C++ signature :
void __init__(struct _object * __ptr64)

__init__( (object)arg1) -> None :

C++ signature :
void __init__(struct _object * __ptr64)

__init__( (object)arg1, (dbgClient)arg2) -> None :

C++ signature :
void __init__(struct _object * __ptr64,class boost::shared_ptr<class pykd::DebugClient> {lvalue})

eventHandler.onBreakpoint

onBreakpoint( (eventHandler)arg1, (object)arg2) -> int :
Triggered breakpoint event. Parameter is int: ID of breakpoint
For ignore event method must return DEBUG_STATUS_NO_CHANGE value

C++ signature :
unsigned long onBreakpoint(class pykd::EventHandlerWrap {lvalue},unsigned long)

eventHandler.onException

onException( (eventHandler)arg1, (dict)arg2) -> int :
Exception event. Parameter is dict:
{"Code":int, "Flags":int, "Record":int, "Address":int, "Parameters":[int], "FirstChance":bool}
Detailed information: http://msdn.microsoft.com/en-us/library/aa363082(VS.85).aspx
For ignore event method must return DEBUG_STATUS_NO_CHANGE value

C++ signature :
unsigned long onException(class pykd::EventHandlerWrap {lvalue},class boost::python::dict)

eventHandler.onLoadModule

onLoadModule( (eventHandler)arg1, (module)arg2) -> int :
Load module event. Parameter is instance of module.
For ignore event method must return DEBUG_STATUS_NO_CHANGE value

C++ signature :
unsigned long onLoadModule(class pykd::EventHandlerWrap {lvalue},class boost::shared_ptr<class pykd::Module>)

eventHandler.onUnloadModule

onUnloadModule( (eventHandler)arg1, (object)arg2) -> int :
Unload module event. Parameter is base address of unloaded module.
For ignore event method must return DEBUG_STATUS_NO_CHANGE value

C++ signature :
unsigned long onUnloadModule(class pykd::EventHandlerWrap {lvalue},unsigned __int64)

Class ext

ext.call

call( (ext)arg1, (unicode)arg2, (unicode)arg3) -> str :
Call debug extension command end return it's result as a string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > call(class pykd::DbgExtension {lvalue},class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >,class std::basic_string<wchar_t,struct std::char_traits<wchar_t>,class std::allocator<wchar_t> >)

Class intBase

intBase

intBase.__add__

__add__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __add__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__and__

__and__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __and__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__div__

__div__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __div__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__eq__

__eq__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __eq__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__ge__

__ge__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __ge__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__gt__

__gt__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __gt__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__hash__

__hash__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __hash__(class pykd::intBase {lvalue})

intBase.__hex__

__hex__( (intBase)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __hex__(class pykd::intBase {lvalue})

intBase.__index__

__index__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __index__(class pykd::intBase {lvalue})

intBase.__init__

__init__( (object)arg1, (object)arg2) -> None :

C++ signature :
void __init__(struct _object * __ptr64,class boost::python::api::object {lvalue})

intBase.__int__

__int__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __int__(class pykd::intBase {lvalue})

intBase.__invert__

__invert__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __invert__(class pykd::intBase {lvalue})

intBase.__le__

__le__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __le__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__long__

__long__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __long__(class pykd::intBase {lvalue})

intBase.__lshift__

__lshift__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __lshift__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__lt__

__lt__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __lt__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__mod__

__mod__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __mod__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__mul__

__mul__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __mul__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__ne__

__ne__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __ne__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__neg__

__neg__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __neg__(class pykd::intBase {lvalue})

intBase.__nonzero__

__nonzero__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __nonzero__(class pykd::intBase {lvalue})

intBase.__or__

__or__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __or__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__pos__

__pos__( (intBase)arg1) -> object :

C++ signature :
class boost::python::api::object __pos__(class pykd::intBase {lvalue})

intBase.__radd__

__radd__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __radd__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rand__

__rand__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rand__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rdiv__

__rdiv__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rdiv__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rlshift__

__rlshift__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rlshift__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rmod__

__rmod__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rmod__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rmul__

__rmul__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rmul__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__ror__

__ror__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __ror__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rrshift__

__rrshift__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rrshift__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rshift__

__rshift__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rshift__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rsub__

__rsub__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rsub__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__rxor__

__rxor__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __rxor__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__str__

__str__( (intBase)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pykd::intBase {lvalue})

intBase.__sub__

__sub__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __sub__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

intBase.__xor__

__xor__( (intBase)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __xor__(class pykd::intBase {lvalue},class boost::python::api::object {lvalue})

Class module

Class representing executable module

module.__getattr__

__getattr__( (module)arg1, (str)arg2) -> int :
Return address of the symbol

C++ signature :
unsigned __int64 __getattr__(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

module.__init__

__init__( (object)arg1, (str)arg2) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

__init__( (object)arg1, (object)arg2) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,unsigned __int64)

module.__str__

__str__( (module)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pykd::Module {lvalue})

module.begin

begin( (module)arg1) -> int :
Return start address of the module

C++ signature :
unsigned __int64 begin(class pykd::Module {lvalue})

module.checksum

checksum( (module)arg1) -> int :
Return a image file checksum: IMAGE_OPTIONAL_HEADER.CheckSum

C++ signature :
unsigned long checksum(class pykd::Module {lvalue})

module.containingRecord

containingRecord( (module)arg1, (object)arg2, (str)arg3, (str)arg4) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(class pykd::Module {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

containingRecord( (module)arg1, (object)arg2, (typeInfo)arg3, (str)arg4) -> typedVar :
Return instance of the typedVar class. It's value are loaded from the target memory.The start address is calculated by the same method as the standard macro CONTAINING_RECORD does

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> containingRecord(class pykd::Module {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

module.end

end( (module)arg1) -> int :
Return end address of the module

C++ signature :
unsigned __int64 end(class pykd::Module {lvalue})

module.image

image( (module)arg1) -> str :
Return name of the image of the module

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > image(class pykd::Module {lvalue})

module.name

name( (module)arg1) -> str :
Return name of the module

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > name(class pykd::Module {lvalue})

module.offset

offset( (module)arg1, (str)arg2) -> int :
Return offset of the symbol

C++ signature :
unsigned __int64 offset(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

module.pdb

pdb( (module)arg1) -> str :
Return the full path to the module's pdb file ( symbol information )

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > pdb(class pykd::Module {lvalue})

module.reload

reload( (module)arg1) -> None :
(Re)load symbols for the module

C++ signature :
void reload(class pykd::Module {lvalue})

module.rva

rva( (module)arg1, (str)arg2) -> int :
Return rva of the symbol

C++ signature :
unsigned long rva(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

module.size

size( (module)arg1) -> int :
Return size of the module

C++ signature :
unsigned long size(class pykd::Module {lvalue})

module.timestamp

timestamp( (module)arg1) -> int :
Return a low 32 bits of the time stamp of the image: IMAGE_FILE_HEADER.TimeDateStamp

C++ signature :
unsigned long timestamp(class pykd::Module {lvalue})

module.type

type( (module)arg1, (str)arg2) -> typeInfo :
Return typeInfo class by type name

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> type(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

module.typedVar

typedVar( (module)arg1, (object)arg2) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::Module {lvalue},unsigned __int64)

typedVar( (module)arg1, (str)arg2) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVar( (module)arg1, (typeInfo)arg2, (object)arg3) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::Module {lvalue},class boost::shared_ptr<class pykd::TypeInfo>,unsigned __int64)

typedVar( (module)arg1, (str)arg2, (object)arg3) -> typedVar :
Return a typedVar class instance

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> typedVar(class pykd::Module {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned __int64)

module.typedVarArray

typedVarArray( (module)arg1, (object)arg2, (str)arg3, (object)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(class pykd::Module {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned long)

typedVarArray( (module)arg1, (object)arg2, (typeInfo)arg3, (object)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory

C++ signature :
class boost::python::list typedVarArray(class pykd::Module {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,unsigned long)

module.typedVarList

typedVarList( (module)arg1, (object)arg2, (str)arg3, (str)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(class pykd::Module {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVarList( (module)arg1, (object)arg2, (typeInfo)arg3, (str)arg4) -> list :
Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory

C++ signature :
class boost::python::list typedVarList(class pykd::Module {lvalue},unsigned __int64,class boost::shared_ptr<class pykd::TypeInfo>,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Class stackFrame

Class representing a frame of the call stack

stackFrame.__str__

__str__( (stackFrame)arg1) -> str :
Return stacks frame as string

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pykd::StackFrame {lvalue})

stackFrame.getLocals

getLocals( (stackFrame)arg1 [, (Context)ctx]) -> dict :
Get list of local variables for this stack frame

C++ signature :
class boost::python::dict getLocals(class pykd::StackFrame {lvalue} [,class boost::shared_ptr<class pykd::ThreadContext>])

Class typeInfo

Class representing typeInfo

typeInfo.__getattr__

__getattr__( (typeInfo)arg1, (str)arg2) -> typeInfo :

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> __getattr__(class pykd::TypeInfo {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typeInfo.__getitem__

__getitem__( (typeInfo)arg1, (object)arg2) -> tuple :

C++ signature :
class boost::python::tuple __getitem__(class pykd::TypeInfo {lvalue},unsigned long)

typeInfo.__init__

__init__( (object)arg1, (str)arg2) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typeInfo.__len__

__len__( (typeInfo)arg1) -> int :

C++ signature :
unsigned long __len__(class pykd::TypeInfo {lvalue})

typeInfo.__str__

__str__( (typeInfo)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pykd::TypeInfo {lvalue})

typeInfo.asMap

asMap( (typeInfo)arg1) -> dict :

C++ signature :
class boost::python::dict asMap(class pykd::TypeInfo {lvalue})

typeInfo.bitOffset

bitOffset( (typeInfo)arg1) -> int :

C++ signature :
unsigned long bitOffset(class pykd::TypeInfo {lvalue})

typeInfo.bitWidth

bitWidth( (typeInfo)arg1) -> int :

C++ signature :
unsigned long bitWidth(class pykd::TypeInfo {lvalue})

typeInfo.deref

deref( (typeInfo)arg1) -> typeInfo :

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> deref(class pykd::TypeInfo {lvalue})

typeInfo.field

field( (typeInfo)arg1, (str)arg2) -> typeInfo :

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> field(class pykd::TypeInfo {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typeInfo.name

name( (typeInfo)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > name(class pykd::TypeInfo {lvalue})

typeInfo.offset

offset( (typeInfo)arg1) -> int :

C++ signature :
unsigned __int64 offset(class pykd::TypeInfo {lvalue})

typeInfo.size

size( (typeInfo)arg1) -> int :

C++ signature :
unsigned long size(class pykd::TypeInfo {lvalue})

Class typedVar

Class of non-primitive type object, child class of typeClass. Data from target is copied into object instance

typedVar.__getattr__

__getattr__( (typedVar)arg1, (str)arg2) -> typedVar :
Return field of structure as an object attribute

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> __getattr__(class pykd::TypedVar {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVar.__getitem__

__getitem__( (typedVar)arg1, (object)arg2) -> object :

C++ signature :
class boost::python::api::object __getitem__(class pykd::TypedVar {lvalue},unsigned long)

__getitem__( (typedVar)arg1, (typedVar)arg2) -> object :

C++ signature :
class boost::python::api::object __getitem__(class pykd::TypedVar {lvalue},class boost::shared_ptr<class pykd::TypedVar>)

typedVar.__init__

__init__( (object)arg1, (str)arg2) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

__init__( (object)arg1, (str)arg2, (object)arg3) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,unsigned __int64)

__init__( (object)arg1, (typeInfo)arg2, (object)arg3) -> object :

C++ signature :
void * __ptr64 __init__(class boost::python::api::object,class boost::shared_ptr<class pykd::TypeInfo>,unsigned __int64)

typedVar.__len__

__len__( (typedVar)arg1) -> int :

C++ signature :
unsigned long __len__(class pykd::TypedVar {lvalue})

typedVar.__str__

__str__( (typedVar)arg1) -> str :

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > __str__(class pykd::TypedVar {lvalue})

typedVar.dataKind

dataKind( (typedVar)arg1) -> int :
Retrieves the variable classification of a data: DataIsXxx

C++ signature :
unsigned long dataKind(class pykd::TypedVar {lvalue})

typedVar.deref

deref( (typedVar)arg1) -> typedVar :
Return value by pointer

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> deref(class pykd::TypedVar {lvalue})

typedVar.field

field( (typedVar)arg1, (str)arg2) -> typedVar :
Return field of structure as an object attribute

C++ signature :
class boost::shared_ptr<class pykd::TypedVar> field(class pykd::TypedVar {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

typedVar.getAddress

getAddress( (typedVar)arg1) -> int :
Return virtual address

C++ signature :
unsigned __int64 getAddress(class pykd::TypedVar {lvalue})

typedVar.offset

offset( (typedVar)arg1) -> int :
Return offset to parent

C++ signature :
unsigned __int64 offset(class pykd::TypedVar {lvalue})

typedVar.sizeof

sizeof( (typedVar)arg1) -> int :
Return size of a variable in the target memory

C++ signature :
unsigned long sizeof(class pykd::TypedVar {lvalue})

Last edited May 30, 2012 at 11:12 AM by kernelnet, version 2

Comments

No comments yet.