zjgcjy/pykd
1
0
Fork 0
mirror of https://github.com/ivellioscolin/pykd.git synced 2025-04-20 03:23:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[0.3.x] added : createUnion, createStruct

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@85614 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2013-10-07 07:14:12 +00:00 committed by Mikhail I. Izmestev
parent bdf469e750
commit 945b976bbf
4 changed files with 53 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
pykd/pymod.cpp
View File

@ -57,13 +57,15 @@ BOOST_PYTHON_FUNCTION_OVERLOADS( getSourceFile_, kdlib::getSourceFile, 0, 1 );
//BOOST_PYTHON_FUNCTION_OVERLOADS( setHardwareBp_, setHardwareBp, 3, 4 ); //BOOST_PYTHON_FUNCTION_OVERLOADS( setHardwareBp_, setHardwareBp, 3, 4 );
// //
//BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( TypeBuilder_createStruct, TypeBuilder::createStruct, 1, 2 ); BOOST_PYTHON_FUNCTION_OVERLOADS( createStruct_, kdlib::defineStruct, 1, 2 );
// //
BOOST_PYTHON_FUNCTION_OVERLOADS( Module_enumSymbols, ModuleAdapter::enumSymbols, 1, 2 ); BOOST_PYTHON_FUNCTION_OVERLOADS( Module_enumSymbols, ModuleAdapter::enumSymbols, 1, 2 );
BOOST_PYTHON_FUNCTION_OVERLOADS( Module_findSymbol, ModuleAdapter::findSymbol, 2, 3 ); BOOST_PYTHON_FUNCTION_OVERLOADS( Module_findSymbol, ModuleAdapter::findSymbol, 2, 3 );
BOOST_PYTHON_FUNCTION_OVERLOADS( findSymbol_, TypeInfoAdapter::findSymbol, 1, 2 ); BOOST_PYTHON_FUNCTION_OVERLOADS( findSymbol_, TypeInfoAdapter::findSymbol, 1, 2 );
BOOST_PYTHON_FUNCTION_OVERLOADS( TypeInfo_ptrTo, TypeInfoAdapter::ptrTo, 1, 2 );
//BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( Module_findSymbol, Module::getSymbolNameByVa, 1, 2 ); //BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( Module_findSymbol, Module::getSymbolNameByVa, 1, 2 );
@ -257,8 +259,12 @@ BOOST_PYTHON_MODULE( pykd )
python::def("containingRecord", &TypedVarAdapter::containingRecordByType, python::def("containingRecord", &TypedVarAdapter::containingRecordByType,
"Return instance of the typedVar class. It's value are loaded from the target memory." "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" ); "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" );
python::def("customStruct", &kdlib::defineStruct, python::def("createStruct", &kdlib::defineStruct,
"return custom defined struct" ); "return custom defined struct" );
python::def( "createStruct", &kdlib::defineStruct, createStruct_( python::args( "name", "align" ),
"Create custom struct" ) );
python::def( "createUnion", &kdlib::defineUnion,
"Create custom union" );
// CPU registers // CPU registers
python::def( "reg", &getRegisterByName, python::def( "reg", &getRegisterByName,
@ -409,10 +415,6 @@ BOOST_PYTHON_MODULE( pykd )
"Return a size of the type or variable" ) "Return a size of the type or variable" )
.def("type", &kdlib::Module::getTypeByName, .def("type", &kdlib::Module::getTypeByName,
"Return typeInfo class by type name" ) "Return typeInfo class by type name" )
//.def("getUdts", &Module::getUdts,
// "Return a list of all user-defined type names" )
//.def("getEnums", &Module::getEnums,
// "Return a list of all enumeration names" )
.def("typedVar", &kdlib::Module::getTypedVarByAddr, .def("typedVar", &kdlib::Module::getTypedVarByAddr,
"Return a typedVar class instance" ) "Return a typedVar class instance" )
.def("typedVar",&kdlib::Module::getTypedVarByName, .def("typedVar",&kdlib::Module::getTypedVarByName,
@ -467,10 +469,10 @@ BOOST_PYTHON_MODULE( pykd )
// "Return type as python dict ( for enum types )" ) // "Return type as python dict ( for enum types )" )
.def( "deref", &kdlib::TypeInfo::deref, .def( "deref", &kdlib::TypeInfo::deref,
"Return type of pointer" ) "Return type of pointer" )
//.def( "append", &kdlib::TypeInfo::appendField, .def( "append", &kdlib::TypeInfo::appendField,
// "Add a new field to custom defined struct" ) "Add a new field to custom defined struct" )
.def( "ptrTo", &kdlib::TypeInfo::ptrTo, .def( "ptrTo", &TypeInfoAdapter::ptrTo, TypeInfo_ptrTo( python::args( "ptrSize" ),
"Return pointer to the type" ) "Return pointer to the type" ) )
.def( "arrayOf", &kdlib::TypeInfo::arrayOf, .def( "arrayOf", &kdlib::TypeInfo::arrayOf,
"Return array of the type" ) "Return array of the type" )
.def( "isArray", &kdlib::TypeInfo::isArray, .def( "isArray", &kdlib::TypeInfo::isArray,
@ -519,8 +521,6 @@ BOOST_PYTHON_MODULE( pykd )
"Return list of tuple ( filedName, fieldOffset, fieldValue )" ) "Return list of tuple ( filedName, fieldOffset, fieldValue )" )
.def( "fieldName", &kdlib::TypedVar::getElementName, .def( "fieldName", &kdlib::TypedVar::getElementName,
"Return name of struct field by index" ) "Return name of struct field by index" )
//.def( "dataKind", &kdlib::TypedVar::getDataKind,
// "Retrieves the variable classification of a data: DataIsXxx")
.def("deref", &kdlib::TypedVar::deref, .def("deref", &kdlib::TypedVar::deref,
"Return value by pointer" ) "Return value by pointer" )
.def("type", &kdlib::TypedVar::getType, .def("type", &kdlib::TypedVar::getType,
@ -578,12 +578,6 @@ BOOST_PYTHON_MODULE( pykd )
.def("__getattr__", &CPUContextAdaptor::getRegisterByName ) .def("__getattr__", &CPUContextAdaptor::getRegisterByName )
.def("__getitem__", &CPUContextAdaptor::getRegisterByIndex ); .def("__getitem__", &CPUContextAdaptor::getRegisterByIndex );
// python::class_<ScopeVars,ScopeVarsPtr,boost::noncopyable>( "locals",
// "Class for access to local vars", python::no_init )
// .def("__len__", &ScopeVars::getVarCount )
// .def("__getitem__", &ScopeVars::getVarByIndex )
// .def("__getitem__", &ScopeVars::getVarByName );
python::class_<kdlib::SystemInfo>( python::class_<kdlib::SystemInfo>(
"systemVersion", "Operation system version", python::no_init) "systemVersion", "Operation system version", python::no_init)
//.def_readonly( "platformId", &SystemVersion::platformId, //.def_readonly( "platformId", &SystemVersion::platformId,

4
pykd/typeinfo.h
View File

@ -73,6 +73,10 @@ struct TypeInfoAdapter : public kdlib::TypeInfo {
return typeInfo.getElement(index); return typeInfo.getElement(index);
} }
static kdlib::TypeInfoPtr ptrTo( kdlib::TypeInfo &typeInfo, size_t ptrSize = 0 ) {
return typeInfo.ptrTo(ptrSize);
}
}; };
struct BaseTypesEnum { struct BaseTypesEnum {

94
test/scripts/customtypestest.py
View File

@ -3,27 +3,25 @@
import unittest import unittest
import target import target
import pykd import pykd
from pykd import baseTypes
class CustomTypesTest(unittest.TestCase): class CustomTypesTest(unittest.TestCase):
def testCommonStruct(self): def testCommonStruct(self):
mySubStruct =pykd.createStruct("MySubCustomStruct")
mySubStruct.append( "m_uint1", baseTypes.UInt1B )
mySubStruct.append( "m_uint2", baseTypes.UInt2B )
tb = pykd.typeBuilder() mySubUnion = pykd.createUnion("MySubCustomUnion")
mySubUnion.append( "m_uint1", baseTypes.UInt1B )
mySubStruct =tb.createStruct("MySubCustomStruct") mySubUnion.append( "m_uint2", baseTypes.UInt2B )
mySubStruct.append( "m_uint1", tb.UInt1B )
mySubStruct.append( "m_uint2", tb.UInt2B )
mySubUnion = tb.createUnion("MySubCustomUnion") myType =pykd.createStruct("MyCustomStruct")
mySubUnion.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint1", baseTypes.UInt1B )
mySubUnion.append( "m_uint2", tb.UInt2B ) myType.append( "m_uint4", baseTypes.UInt4B )
myType.append( "m_uint2", baseTypes.UInt2B )
myType = tb.createStruct("MyCustomStruct")
myType.append( "m_uint1", tb.UInt1B )
myType.append( "m_uint4", tb.UInt4B )
myType.append( "m_uint2", tb.UInt2B )
myType.append( "m_struct", mySubStruct ) myType.append( "m_struct", mySubStruct )
myType.append( "m_union", mySubUnion ) myType.append( "m_union", mySubUnion )
myType.append( "m_uint8", tb.UInt8B ) myType.append( "m_uint8", baseTypes.UInt8B )
self.assertTrue( myType.size() != 0 ) self.assertTrue( myType.size() != 0 )
self.assertTrue( myType.size() >= myType.fieldOffset("m_uint8") + myType.m_uint8.size() ) self.assertTrue( myType.size() >= myType.fieldOffset("m_uint8") + myType.m_uint8.size() )
@ -42,16 +40,12 @@ class CustomTypesTest(unittest.TestCase):
self.assertTrue( myType.fieldOffset("m_struct") < myType.fieldOffset("m_union") ) self.assertTrue( myType.fieldOffset("m_struct") < myType.fieldOffset("m_union") )
self.assertTrue( myType.fieldOffset("m_struct") + myType.m_struct.size() <= myType.fieldOffset("m_union") ) self.assertTrue( myType.fieldOffset("m_struct") + myType.m_struct.size() <= myType.fieldOffset("m_union") )
# print myType
def testCommonUnion(self): def testCommonUnion(self):
tb = pykd.typeBuilder() myType = pykd.createUnion("MyCustomStruct")
myType.append( "m_uint1", baseTypes.UInt1B )
myType = tb.createUnion("MyCustomStruct") myType.append( "m_uint4", baseTypes.UInt4B )
myType.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint2", baseTypes.UInt2B )
myType.append( "m_uint4", tb.UInt4B )
myType.append( "m_uint2", tb.UInt2B )
self.assertFalse( myType.size() == 0 ) self.assertFalse( myType.size() == 0 )
self.assertTrue( myType.fieldOffset("m_uint1") == 0 ) self.assertTrue( myType.fieldOffset("m_uint1") == 0 )
@ -59,74 +53,46 @@ class CustomTypesTest(unittest.TestCase):
self.assertTrue( myType.fieldOffset("m_uint2") == 0 ) self.assertTrue( myType.fieldOffset("m_uint2") == 0 )
def testEmptyType(self): def testEmptyType(self):
tb = pykd.typeBuilder()
myEmptyStruct1 = pykd.createStruct("EmptyStruct1")
myEmptyStruct1 = tb.createStruct("EmptyStruct1")
self.assertEqual( 0, myEmptyStruct1.size() ) self.assertEqual( 0, myEmptyStruct1.size() )
myEmptyStruct1.append("m_emptyStruct2", tb.createStruct("EmptyStruct2")) myEmptyStruct1.append("m_emptyStruct2", pykd.createStruct("EmptyStruct2"))
self.assertEqual( 0, myEmptyStruct1.size() ) self.assertEqual( 0, myEmptyStruct1.size() )
myEmptyUnion1 = tb.createUnion("EmptyUnion1") myEmptyUnion1 = pykd.createUnion("EmptyUnion1")
self.assertEqual( 0, myEmptyUnion1.size() ) self.assertEqual( 0, myEmptyUnion1.size() )
myEmptyStruct1.append("m_emptyUnion2", myEmptyUnion1) myEmptyStruct1.append("m_emptyUnion2", myEmptyUnion1)
self.assertEqual( 0, myEmptyStruct1.size() ) self.assertEqual( 0, myEmptyStruct1.size() )
myEmptyUnion1.append("m_emptyStruct3", tb.createStruct("EmptyStruct3")) myEmptyUnion1.append("m_emptyStruct3", pykd.createStruct("EmptyStruct3"))
self.assertEqual( 0, myEmptyUnion1.size() ) self.assertEqual( 0, myEmptyUnion1.size() )
def testDupFieldName(self): def testDupFieldName(self):
tb = pykd.typeBuilder() myType = pykd.createStruct("MyCustomStruct")
myType = tb.createStruct("MyCustomStruct")
exceptionRised = False exceptionRised = False
myType.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint1", baseTypes.UInt1B )
try: try:
myType.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint1", baseTypes.UInt1B )
except pykd.TypeException: except pykd.TypeException:
exceptionRised = True exceptionRised = True
self.assertTrue(exceptionRised) self.assertTrue(exceptionRised)
myType = tb.createUnion("MyCustomStruct") myType = pykd.createUnion("MyCustomStruct")
exceptionRised = False exceptionRised = False
myType.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint1", baseTypes.UInt1B )
try: try:
myType.append( "m_uint1", tb.UInt1B ) myType.append( "m_uint1", baseTypes.UInt1B )
except pykd.TypeException: except pykd.TypeException:
exceptionRised = True exceptionRised = True
self.assertTrue(exceptionRised) self.assertTrue(exceptionRised)
def testBasicType(self):
tb = pykd.typeBuilder()
self.assertEqual( 1, tb.UInt1B.size() )
self.assertEqual( 2, tb.UInt2B.size() )
self.assertEqual( 4, tb.UInt4B.size() )
self.assertEqual( 8, tb.UInt8B.size() )
self.assertEqual( 1, tb.Int1B.size() )
self.assertEqual( 2, tb.Int2B.size() )
self.assertEqual( 4, tb.Int4B.size() )
self.assertEqual( 8, tb.Int8B.size() )
self.assertEqual( 1, tb.Bool.size() )
self.assertEqual( 1, tb.Char.size() )
self.assertEqual( 2, tb.WChar.size() )
self.assertEqual( 4, tb.Long.size() )
self.assertEqual( 4, tb.ULong.size() )
def testVoidPtr(self):
self.assertEqual( 4, pykd.typeBuilder(4).VoidPtr.size() )
self.assertEqual( 8, pykd.typeBuilder(8).VoidPtr.size() )
self.assertEqual( pykd.ptrSize(), pykd.typeBuilder().VoidPtr.size() )
self.assertEqual( 4, pykd.typeBuilder(4).UInt1B.ptrTo().size() )
self.assertEqual( 8, pykd.typeBuilder(8).UInt1B.ptrTo().size() )
self.assertEqual( pykd.ptrSize(), pykd.typeBuilder().UInt1B.ptrTo().size() )
def testPtrToCustomType(self): def testPtrToCustomType(self):
tb = pykd.typeBuilder() mySubStruct =pykd.createStruct("MySubCustomStruct")
mySubStruct =tb.createStruct("MySubCustomStruct") mySubStruct.append( "m_uint1", baseTypes.UInt1B )
mySubStruct.append( "m_uint1", tb.UInt1B ) mySubStruct.append( "m_uint2", baseTypes.UInt2B )
mySubStruct.append( "m_uint2", tb.UInt2B )
mySubStructPtr = mySubStruct.ptrTo() mySubStructPtr = mySubStruct.ptrTo()
self.assertEqual( pykd.ptrSize(), mySubStructPtr.size() ) self.assertEqual( pykd.ptrSize(), mySubStructPtr.size() )

12
test/scripts/pykdtest.py
View File

@ -20,10 +20,11 @@ import typeinfo
import typedvar import typedvar
import breakpoint import breakpoint
import regtest import regtest
import stacktest
import customtypestest
#import mspdbtest #import mspdbtest
#import localstest
#import customtypestest
#import ehexcepttest #import ehexcepttest
#import ehstatustest #import ehstatustest
#import ehsymbolstest #import ehsymbolstest
@ -54,16 +55,16 @@ def getTestSuite( singleName = "" ):
unittest.TestLoader().loadTestsFromTestCase( typeinfo.TypeInfoTest ), unittest.TestLoader().loadTestsFromTestCase( typeinfo.TypeInfoTest ),
unittest.TestLoader().loadTestsFromTestCase( typedvar.TypedVarTest ), unittest.TestLoader().loadTestsFromTestCase( typedvar.TypedVarTest ),
unittest.TestLoader().loadTestsFromTestCase( regtest.CpuRegTest ), unittest.TestLoader().loadTestsFromTestCase( regtest.CpuRegTest ),
#unittest.TestLoader().loadTestsFromTestCase( customtypestest.CustomTypesTest ), unittest.TestLoader().loadTestsFromTestCase( customtypestest.CustomTypesTest ),
# ^^^ # ^^^
unittest.TestLoader().loadTestsFromTestCase( TerminateProcessTest ), unittest.TestLoader().loadTestsFromTestCase( TerminateProcessTest ),
unittest.TestLoader().loadTestsFromTestCase( breakpoint.BreakpointTest ), unittest.TestLoader().loadTestsFromTestCase( breakpoint.BreakpointTest ),
unittest.TestLoader().loadTestsFromTestCase( stacktest.StackTest ),
#unittest.TestLoader().loadTestsFromTestCase( localstest.LocalVarsTest )
#unittest.TestLoader().loadTestsFromTestCase( mspdbtest.MsPdbTest ), #unittest.TestLoader().loadTestsFromTestCase( mspdbtest.MsPdbTest ),
#unittest.TestLoader().loadTestsFromTestCase( localstest.LocalVarsTest ),
#unittest.TestLoader().loadTestsFromTestCase( ehexcepttest.EhExceptionTest ), #unittest.TestLoader().loadTestsFromTestCase( ehexcepttest.EhExceptionTest ),
#unittest.TestLoader().loadTestsFromTestCase( ehstatustest.EhStatusTest ), #unittest.TestLoader().loadTestsFromTestCase( ehstatustest.EhStatusTest ),
#unittest.TestLoader().loadTestsFromTestCase( ehsymbolstest.EhSymbolsTest ), #unittest.TestLoader().loadTestsFromTestCase( ehsymbolstest.EhSymbolsTest ),
@ -84,3 +85,4 @@ if __name__ == "__main__":
target.moduleName = os.path.splitext(os.path.basename(target.appPath))[0] target.moduleName = os.path.splitext(os.path.basename(target.appPath))[0]
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run( getTestSuite() ) unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run( getTestSuite() )