PYKD 0.2.0.17 API Reference

Functions

Classes

Function addr64

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

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

Function appendSymbolPath

appendSymbolPath( (str)arg1) -> None :
Append current symbol path

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

Function attachProcess

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

C++ signature :
unsigned long attachProcess(unsigned long)

Function breakin

breakin() -> None :
Break into debugger

C++ signature :
void breakin()

Function bugCheckData

bugCheckData() -> tuple :
Function reads the kernel bug check code and related parameters
And return tuple: (code, arg1, arg2, arg3, arg4)

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

Function callExt

callExt( (object)arg1, (unicode)arg2, (unicode)arg3) -> str :
Call a WinDBG extension's routine. Parameters: handle returned by loadExt; string command line

C++ signature :
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > callExt(unsigned __int64,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> >)

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 currentTime

currentTime() -> int :
Return the number of seconds since the beginning of 1970

C++ signature :
unsigned long currentTime()

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 detachProcess

detachProcess([ (object)pid]) -> None :
Stop process debugging

C++ signature :
void detachProcess([ unsigned long])

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 findMemoryRegion

findMemoryRegion( (object)arg1) -> tuple :
Return address of begining valid memory region nearest to offset

C++ signature :
class boost::python::tuple findMemoryRegion(unsigned __int64)

Function findSymbol

findSymbol( (object)offset [, (bool)safe]) -> 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 [,bool])

Function getCurrentProcess

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

C++ signature :
unsigned __int64 getCurrentProcess()

Function getFrame

getFrame() -> stackFrame :
Return a current stack frame

C++ signature :
class boost::shared_ptr<class pykd::StackFrame> getFrame()

Function getImplicitThread

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

C++ signature :
unsigned __int64 getImplicitThread()

Function getLocals

getLocals() -> locals :
Get list of local variables

C++ signature :
class boost::shared_ptr<class pykd::ScopeVars> getLocals()

Function getOffset

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

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

Function getParams

getParams() -> locals :
Get list of function arguments

C++ signature :
class boost::shared_ptr<class pykd::ScopeVars> getParams()

Function getProcessThreads

getProcessThreads() -> list :
Get all process's threads ( user mode only )

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

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 getSourceFile

getSourceFile([ (object)offset]) -> str :
Return source file by the specified offset

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

Function getSourceLine

getSourceLine([ (object)offset]) -> tuple :
Return source file name, line and displacement by the specified offset

C++ signature :
class boost::python::tuple getSourceLine([ unsigned __int64])

Function getStack

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

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

Function getStackWow64

getStackWow64() -> list :
Return a stack for wow64 context as a list of stackFrame objects

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

Function getSymbolPath

getSymbolPath() -> str :
Returns current symbol path

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

Function getVaProtect

getVaProtect( (object)arg1) -> int :
Return memory attributes

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

Function go

go() -> None :
Go debugging

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( (object)arg1) -> None :
Stop debugging and terminate current process

C++ signature :
void killProcess(unsigned long)

Function lastEvent

lastEvent() -> eventType :
Return type of last event: eventType

C++ signature :
enum pykd::EVENT_TYPE lastEvent()

Function lastException

lastException() -> exceptionInfo :
Return data of last exception event: exceptionInfo

C++ signature :
class boost::shared_ptr<struct pykd::ExceptionInfo> lastException()

Function loadAnsiString

loadAnsiString( (object)arg1) -> 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(unsigned __int64)

Function loadBytes

loadBytes( (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(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 loadDoubles

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

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

Function loadDump

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

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) -> int :
Load a WinDBG extension. Return handle of the loaded extension

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

Function loadFloats

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

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

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 pageSize

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

C++ signature :
unsigned long pageSize()

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 ptrDouble

ptrDouble( (object)arg1) -> float :
Read a float with single precision from the target memory

C++ signature :
double ptrDouble(unsigned __int64)

Function ptrFloat

ptrFloat( (object)arg1) -> float :
Read a float with single precision from the target memory

C++ signature :
double ptrFloat(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)

Function removeExt

removeExt( (object)arg1) -> None :
Unload a WinDBG extension. Parameters: handle returned by loadExt

C++ signature :
void removeExt(unsigned __int64)

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 setImplicitThread

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

C++ signature :
void setImplicitThread(unsigned __int64)

Function setProcessorMode

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

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

Function setSymSrvDir

setSymSrvDir( (unicode)arg1) -> None :
Set directory of SYMSRV.dll library.
Usually this is a directory of WinDbg

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

Function setSymbolPath

setSymbolPath( (str)arg1) -> None :
Set current symbol path

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

Function sizeof

sizeof( (str)arg1) -> int :
Return a size of the type or variable

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

Function startProcess

startProcess( (unicode)arg1) -> int :
Start process for debugging

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

Function step

step() -> None :
The target is executing a single instruction or--if that instruction is a subroutine call--subroutine

C++ signature :
void step()

Function systemUptime

systemUptime() -> int :
Return the number of seconds the computer has been running

C++ signature :
unsigned long systemUptime()

Function trace

trace() -> None :
The target is executing a single instruction

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 writeDump

writeDump( (unicode)arg1, (bool)arg2) -> None :
Create memory dump file

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

Function wrmsr

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

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

Class cpuReg

CPU regsiter class

Methods:

Method cpuReg.index

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

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

Method 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 din

din

Methods:

readline

Method 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

Methods:

Method 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)

Method 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> >)

Method disasm.begin

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

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

Method disasm.current

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

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

Method 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( (disasm)arg1, (object)arg2) -> str :
Disassemble from the specified offset

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

Method disasm.ea

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

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

Method disasm.findOffset

findOffset( (disasm)arg1, (object)arg2) -> int :
Return the location of a processor instruction relative to a given location

C++ signature :
unsigned __int64 findOffset(class pykd::Disasm {lvalue},long)

Method 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})

Method disasm.jump

jump( (disasm)arg1, (object)arg2) -> str :
Change the current instruction

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

Method disasm.jumprel

jumprel( (disasm)arg1, (object)arg2) -> str :
Change the current instruction

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

Method disasm.length

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

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

Method 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

Methods:

write

Method dout.write

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

C++ signature :
void write(class pykd::DbgErr {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

Methods:

Method eventHandler.init

__init__( (object)arg1) -> None :

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

Method eventHandler.onBreakpoint

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

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

Method eventHandler.onException

onException( (eventHandler)arg1, (exceptionInfo)arg2) -> eventResult :
Triggered exception event. Parameter - exceptionInfo
For ignore event method must return eventResult.noChange

C++ signature :
enum pykd::DEBUG_CALLBACK_RESULT onException(class pykd::EventHandlerWrap {lvalue},class boost::shared_ptr<struct pykd::ExceptionInfo>)

Method eventHandler.onModuleLoad

onModuleLoad( (eventHandler)arg1, (object)arg2, (str)arg3) -> eventResult :
Triggered module load event. Parameter are long: module base, string: module name
For ignore event method must return eventResult.noChange

C++ signature :
enum pykd::DEBUG_CALLBACK_RESULT onModuleLoad(class pykd::EventHandlerWrap {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Method eventHandler.onModuleUnload

onModuleUnload( (eventHandler)arg1, (object)arg2, (str)arg3) -> eventResult :
Triggered module unload event. Parameter are long: module base, string: module name
For ignore event method must return eventResult.noChange

C++ signature :
enum pykd::DEBUG_CALLBACK_RESULT onModuleUnload(class pykd::EventHandlerWrap {lvalue},unsigned __int64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Class exceptionInfo

Exception information

Properties:

Methods:

__str__

Property exceptionInfo.ExceptionAddress

The address where the exception occurred

Property exceptionInfo.ExceptionCode

The reason the exception occurred

Property exceptionInfo.ExceptionFlags

The exception flags

Property exceptionInfo.ExceptionRecord

A pointer to an associated EXCEPTION_RECORD structure

Property exceptionInfo.FirstChance

Specifies whether this exception has been previously encountered

Property exceptionInfo.Parameters

An array of additional arguments that describe the exception

Method exceptionInfo.str

__str__( (exceptionInfo)arg1) -> str :
Return object as a string

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

Class intBase

intBase

Methods:

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method intBase.hash

__hash__( (intBase)arg1) -> object :

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

Method 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})

Method intBase.index

__index__( (intBase)arg1) -> object :

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

Method intBase.init

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

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

Method intBase.int

__int__( (intBase)arg1) -> object :

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

Method intBase.invert

__invert__( (intBase)arg1) -> object :

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

Method 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})

Method intBase.long

__long__( (intBase)arg1) -> object :

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

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method intBase.neg

__neg__( (intBase)arg1) -> object :

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

Method intBase.nonzero

__nonzero__( (intBase)arg1) -> object :

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

Method 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})

Method intBase.pos

__pos__( (intBase)arg1) -> object :

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

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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})

Method 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 locals

Class for access to local vars

Methods:

Method locals.getitem

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

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

__getitem__( (locals)arg1, (str)arg2) -> object :

C++ signature :
class boost::python::api::object __getitem__(class pykd::ScopeVars {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

Method locals.len

__len__( (locals)arg1) -> int :

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

Class module

Class representing executable module

Methods:

Method 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> >)

Method module.init

Method 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})

Method module.begin

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

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

Method module.checksum

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

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

Method 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> >)

Method module.end

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

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

Method module.enumSymbols

enumSymbols( (module)arg1 [, (str)mask]) -> list :
Return list of tuple ( symbolname, offset )

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

Method module.enumTypes

enumTypes( (module)arg1 [, (str)mask]) -> list :
Return list of type's names

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

Method module.findSymbol

findSymbol( (module)arg1, (object)offset [, (bool)showDisplacement]) -> str :
Return symbol name by virtual address

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

Method module.getVersion

getVersion( (module)arg1) -> tuple :
Return tuple of the module's file version

C++ signature :
class boost::python::tuple getVersion(class pykd::Module {lvalue})

Method 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})

Method 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})

Method 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> >)

Method module.queryVersion

queryVersion( (module)arg1, (str)arg2) -> str :
Return string from the module's version resources

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

Method module.reload

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

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

Method 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> >)

Method module.size

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

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

Method module.sizeof

sizeof( (module)arg1, (str)arg2) -> int :
Return a size of the type or variable

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

Method module.symfile

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

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

Method 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})

Method 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> >)

Method 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, (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)

Method 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)

Method 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> >)

Class stackFrame

Class representing a frame of the call stack

Properties:

Methods:

__str__

Property stackFrame.frameNumber

Return a frame's number

Property stackFrame.frameOffset

Return a frame's offset

Property stackFrame.instructionOffset

Return a frame's instruction offset

Property stackFrame.locals

Get list of local variables for this stack frame

Property stackFrame.params

Get list of function params

Property stackFrame.returnOffset

Return a frame's return offset

Property stackFrame.stackOffset

Return a frame's stack offset

Method stackFrame.str

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

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

Class typeBuilder

Class for building dynamically defined types

Properties:

Methods:

Method typeBuilder.init

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

C++ signature :
void __init__(struct _object * __ptr64 [,unsigned long])

Method typeBuilder.createStruct

createStruct( (typeBuilder)arg1, (str)name [, (object)align]) -> typeInfo :
Create custom struct

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> createStruct(class pykd::TypeBuilder {lvalue},class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > [,unsigned long])

Method typeBuilder.createUnion

createUnion( (typeBuilder)arg1, (str)arg2) -> typeInfo :
Create custom union

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

Class typeInfo

Class representing typeInfo

Methods:

Method 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> >)

Method typeInfo.getitem

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

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

Method typeInfo.init

Method typeInfo.len

__len__( (typeInfo)arg1) -> int :

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

Method typeInfo.str

__str__( (typeInfo)arg1) -> str :
Return typa as a printable string

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

Method typeInfo.append

append( (typeInfo)arg1, (str)arg2, (typeInfo)arg3) -> None :
Add a new field to custom defined struct

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

Method typeInfo.arrayOf

arrayOf( (typeInfo)arg1, (object)arg2) -> typeInfo :
Return array of the type

C++ signature :
class boost::shared_ptr<class pykd::TypeInfo> arrayOf(class pykd::TypeInfo {lvalue},unsigned long)

Method typeInfo.asMap

asMap( (typeInfo)arg1) -> dict :
Return type as python dict ( for enum types )

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

Method typeInfo.bitOffset

bitOffset( (typeInfo)arg1) -> int :
Return bit field's offset

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

Method typeInfo.bitWidth

bitWidth( (typeInfo)arg1) -> int :
Return bit field's length

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

Method typeInfo.deref

deref( (typeInfo)arg1) -> typeInfo :
Return type of pointer

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

Method typeInfo.field

field( (typeInfo)arg1, (str)arg2) -> typeInfo :
Return field's type

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

Method typeInfo.fieldOffset

fieldOffset( (typeInfo)arg1, (str)arg2) -> int :
Return offset of the nonstatic field

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

Method typeInfo.name

name( (typeInfo)arg1) -> str :
Return type name

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

Method typeInfo.ptrTo

ptrTo( (typeInfo)arg1) -> typeInfo :
Return pointer to the type

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

Method typeInfo.size

size( (typeInfo)arg1) -> int :
Return type size

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

Method typeInfo.staticOffset

staticOffset( (typeInfo)arg1, (str)arg2) -> int :
Return offset of the static field

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

Class typedVar

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

Methods:

Method 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> >)

Method 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>)

Method 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)

Method typedVar.len

__len__( (typedVar)arg1) -> int :

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

Method 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})

Method typedVar.dataKind

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

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

Method typedVar.deref

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

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

Method 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> >)

Method typedVar.fieldOffset

fieldOffset( (typedVar)arg1, (str)arg2) -> int :
Return target field offset

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

Method typedVar.getAddress

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

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

Method typedVar.sizeof

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

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

Method typedVar.type

type( (typedVar)arg1) -> typeInfo :
Return typeInfo instance

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