[0.3.x] added : check integer overflow for NumVariabt class

git-svn-id: https://pykd.svn.codeplex.com/svn@90962 9b283d60-5439-405e-af05-b73fd8c4d996

pykd/dbgexcept.h

@@ -9,6 +9,13 @@
 
 namespace pykd {
 
+class OverflowException : public std::exception
+{
+public:
+
+    OverflowException(const char* desc) : std::exception(desc)
+    {}
+};
 
 template< class TExcept >
 struct exceptPyType{
@@ -48,8 +55,7 @@ public:
 };
 
 
-
+inline void dbgExceptionTranslate(const kdlib::DbgException &e)
-inline void exceptionTranslate(const kdlib::DbgException &e ) 
 {
     if ( typeid(e).hash_code() == typeid(kdlib::MemoryException).hash_code() )
     {
@@ -82,6 +88,16 @@ inline void exceptionTranslate(const kdlib::DbgException &e )
     PyErr_SetObject( exceptPyType<kdlib::DbgException>::pyExceptType.get(), exceptObj.ptr());
 }
 
+inline void pykdExceptionTranslate(const std::exception &e)
+{
+    if (typeid(e).hash_code() == typeid(OverflowException).hash_code())
+    {
+        PyErr_SetString(PyExc_OverflowError, e.what());
+        return;
+    }
+
+}
+
 inline void registerExceptions()
 {
     pykd::exception<kdlib::DbgException>( "DbgException", "Pykd base exception class" );
@@ -89,7 +105,8 @@ inline void registerExceptions()
     pykd::exception<kdlib::SymbolException,kdlib::DbgException>( "SymbolException", "Symbol exception" );
     pykd::exception<kdlib::TypeException,kdlib::SymbolException>( "TypeException", "type exception" );
 
-    python::register_exception_translator<kdlib::DbgException>( &exceptionTranslate );
+    python::register_exception_translator<kdlib::DbgException>( &dbgExceptionTranslate );
+    python::register_exception_translator<OverflowException>( &pykdExceptionTranslate );
 }
 
 /////////////////////////////////////////////////////////////////////////////////////

pykd/variant.h

@@ -4,6 +4,7 @@
 
 #include "kdlib/variant.h"
 #include "kdlib/exceptions.h"
+#include "dbgexcept.h"
 
 namespace pykd {
 
@@ -42,9 +43,20 @@ public:
 #endif
 
         if (_PyLong_Sign(obj.ptr()) >= 0)
+        {
+            if (_PyLong_NumBits(obj.ptr()) > 64)
+                throw pykd::OverflowException("int too big to convert");
+
             var->m_variant.setULongLong(PyLong_AsUnsignedLongLong(obj.ptr()));
+        }
         else
+        {
+            if (_PyLong_NumBits(obj.ptr()) > 63)
+                throw pykd::OverflowException("int too big to convert");
+
             var->m_variant.setLongLong(PyLong_AsLongLong(obj.ptr()));
+        }
+
 
         return var;
     }

test/scripts/intbase.py

@@ -1,6 +1,7 @@
 
 import unittest
 import target
+import sys
 from pykd import numVariant
 
 class IntBaseTest( unittest.TestCase ):
@@ -15,9 +16,12 @@ class IntBaseTest( unittest.TestCase ):
         a = numVariant(-2000)
         a = numVariant(-200000)
         a = numVariant(-20000000000) 
-        a = numVariant(-0xFFFFFFFFFFFFFFFF )
         a = numVariant( True )
 
+        self.assertRaises(OverflowError, numVariant, -0xFFFFFFFFFFFFFFFF )
+        self.assertRaises(OverflowError, numVariant, 0x10000000000000000 )
+
+        
     def testEq( self ):
         self.assertTrue( 0xFF == numVariant(0xFF) and numVariant(0xFF) == 0xFF )
         self.assertTrue( 0xFFFF == numVariant(0xFFFF) and 0xFFFF == numVariant(0xFFFF) )
@@ -28,7 +32,7 @@ class IntBaseTest( unittest.TestCase ):
         self.assertTrue( -2000 == numVariant(-2000) )
         self.assertTrue( -0x7FFFFFFF == numVariant(-0x7FFFFFFF) )
         self.assertTrue( -20000000000 == numVariant(-20000000000) )
-        self.assertTrue( -0x8000000000000000 == numVariant(-0x8000000000000000) )
+        self.assertTrue( -0x7fffffffffffffff == numVariant(-0x7fffffffffffffff) )
         #self.assertTrue( numVariant(0x20L) == numVariant(0x20) )
         self.assertTrue( True == numVariant(True) )
         self.assertTrue( False == numVariant(0) )
@@ -44,7 +48,7 @@ class IntBaseTest( unittest.TestCase ):
         self.assertTrue( -20 + 1 != numVariant(-20) )        
         self.assertTrue( -2000 + 1 != numVariant(-2000) )        
         self.assertTrue( -20000000000 + 1 != numVariant(-20000000000) )
-        self.assertTrue( -0x8000000000000000 - 1 != numVariant(-0x8000000000000000) )
+        self.assertTrue( -0x8000000000000000 - 1 != numVariant(-0x7fffffffffffffff) )
         self.assertTrue( numVariant(1) != numVariant(2) )
         
     def testLtGt( self ):
@@ -73,8 +77,8 @@ class IntBaseTest( unittest.TestCase ):
         self.assertEqual( -20, numVariant(-10) + (-10) )
         self.assertEqual( 10, numVariant(-10) + 20 )
         self.assertEqual( 0x7fffffffffffffff + 1, numVariant(0x7fffffffffffffff) + 1)
-        self.assertEqual( -0x8000000000000000 + 10, numVariant(-0x8000000000000000) + 10 )
+        self.assertEqual( -0x7fffffffffffffff + 10, numVariant(-0x7fffffffffffffff) + 10 )
-        self.assertEqual( 0, numVariant(-0x8000000000000000) + 0x8000000000000000 )
+        self.assertEqual( 0, numVariant(-0x7fffffffffffffff) + 0x7fffffffffffffff )
         self.assertEqual( 5, numVariant(3) + numVariant(2) )
 
     def testSub( self ):