From f82e7929d878c03881f040a6ef85ee60dadd61c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20K=C3=B6fferlein?= Date: Sat, 20 Jul 2019 00:28:32 +0200 Subject: [PATCH] Fixed a conversion issue with ints on MSVC Because long is 32bit on Windows (like int), the conversion from long to unsigned int was subject to sign overflow. This was fixed by going to unsigned int via unsigned long. --- src/gsi/gsi_test/gsiTest.cc | 16 ++++++++++++++++ src/gsi/gsi_test/gsiTest.h | 17 +++++++++++++++++ src/pya/pya/pyaConvert.h | 4 ++-- src/pya/unit_tests/pya.cc | 2 +- src/rba/unit_tests/rba.cc | 2 +- testdata/python/basic.py | 20 ++++++++++++++++++++ testdata/ruby/basic_testcore.rb | 21 +++++++++++++++++++++ 7 files changed, 78 insertions(+), 4 deletions(-) diff --git a/src/gsi/gsi_test/gsiTest.cc b/src/gsi/gsi_test/gsiTest.cc index c99eeab2c..105b23bac 100644 --- a/src/gsi/gsi_test/gsiTest.cc +++ b/src/gsi/gsi_test/gsiTest.cc @@ -834,6 +834,14 @@ static gsi::Class decl_a ("", "A", #endif gsi::method ("*a10_prot", &A::a10_d) + gsi::method ("a10_f", &A::a10_f) + + gsi::method ("a10_s", &A::a10_s) + + gsi::method ("a10_us", &A::a10_us) + + gsi::method ("a10_i", &A::a10_i) + + gsi::method ("a10_l", &A::a10_l) + + gsi::method ("a10_ll", &A::a10_ll) + + gsi::method ("a10_ui", &A::a10_ui) + + gsi::method ("a10_ul", &A::a10_ul) + + gsi::method ("a10_ull", &A::a10_ull) + gsi::method ("a10_fptr", &A::a10_fptr) + gsi::method ("a10_dptr", &A::a10_dptr) + gsi::method ("a10_iptr", &A::a10_iptr) + @@ -874,6 +882,14 @@ static gsi::Class decl_a ("", "A", gsi::method ("a10_cllref", &A::a10_cllref) + gsi::method ("a10_cullref", &A::a10_cullref) + gsi::method ("a10_csref", &A::a10_csref) + + gsi::method ("a11_s", &A::a11_s) + + gsi::method ("a11_us", &A::a11_us) + + gsi::method ("a11_i", &A::a11_i) + + gsi::method ("a11_l", &A::a11_l) + + gsi::method ("a11_ll", &A::a11_ll) + + gsi::method ("a11_ui", &A::a11_ui) + + gsi::method ("a11_ul", &A::a11_ul) + + gsi::method ("a11_ull", &A::a11_ull) + gsi::method ("a_vp1", &A::a_vp1) + gsi::method ("a_vp2", &A::a_vp2) + gsi::method ("a9a", &A::a9a) + diff --git a/src/gsi/gsi_test/gsiTest.h b/src/gsi/gsi_test/gsiTest.h index a7e6938f6..c3c366815 100644 --- a/src/gsi/gsi_test/gsiTest.h +++ b/src/gsi/gsi_test/gsiTest.h @@ -155,6 +155,15 @@ struct A bool a9a (int i) const { return i == 5; } int a9b (bool f) const { return f ? 5 : -5; } + short a11_s (double f) { return short(f); } + unsigned short a11_us (double f) { return (unsigned short)(f); } + int a11_i (double f) { return int(f); } + unsigned int a11_ui (double f) { return (unsigned int)(f); } + long a11_l (double f) { return long(f); } + unsigned long a11_ul (double f) { return (unsigned long)(f); } + long long a11_ll (double f) { return (long long)(f); } + unsigned long long a11_ull (double f) { return (unsigned long long)(f); } + std::string a10_d (double f) { return tl::to_string (f); } #if defined(HAVE_QT) QByteArray a10_d_qba (double f) { return tl::to_qstring (tl::to_string (f)).toUtf8 (); } @@ -162,6 +171,14 @@ struct A QStringRef a10_d_qstrref (double f) { m_s = tl::to_qstring (tl::to_string (f)); return QStringRef (&m_s); } #endif std::string a10_f (float f) { return tl::to_string(f); } + std::string a10_s (short l) { return tl::to_string(int (l)); } + std::string a10_us (unsigned short l) { return tl::to_string(int (l)); } + std::string a10_i (int l) { return tl::to_string(l); } + std::string a10_ui (unsigned int l) { return tl::to_string(l); } + std::string a10_l (long l) { return tl::to_string(l); } + std::string a10_ul (unsigned long l) { return tl::to_string(l); } + std::string a10_ll (long long l) { return tl::to_string(l); } + std::string a10_ull (unsigned long long l) { return tl::to_string(l); } std::string a10_fptr (float *f) { if (f) { *f += 5; return tl::to_string(*f); } else { return "nil"; } } std::string a10_dptr (double *f) { if (f) { *f += 6; return tl::to_string(*f); } else { return "nil"; } } std::string a10_iptr (int *f) { if (f) { *f += 7; return tl::to_string(*f); } else { return "nil"; } } diff --git a/src/pya/pya/pyaConvert.h b/src/pya/pya/pyaConvert.h index 4f24c077c..81624491a 100644 --- a/src/pya/pya/pyaConvert.h +++ b/src/pya/pya/pyaConvert.h @@ -320,7 +320,7 @@ template <> struct python2c_func : public python2c_func_cast struct python2c_func : public python2c_func_cast { }; template <> struct python2c_func : public python2c_func_cast { }; template <> struct python2c_func : public python2c_func_cast { }; -template <> struct python2c_func : public python2c_func_cast { }; +template <> struct python2c_func : public python2c_func_cast { }; template <> PYA_PUBLIC long long python2c_func::operator() (PyObject *rval); template <> PYA_PUBLIC unsigned long long python2c_func::operator() (PyObject *rval); @@ -540,7 +540,7 @@ struct c2python_func { PyObject *operator() (unsigned int c) { - return PyLong_FromLong (long (c)); + return PyLong_FromUnsignedLong ((unsigned long) (c)); } }; diff --git a/src/pya/unit_tests/pya.cc b/src/pya/unit_tests/pya.cc index 38faf5e5a..3cecf497d 100644 --- a/src/pya/unit_tests/pya.cc +++ b/src/pya/unit_tests/pya.cc @@ -30,7 +30,7 @@ static void run_pythontest (tl::TestBase *_this, const std::string &fn); -TEST (1) +TEST (basic) { EXPECT_EQ (gsi::has_class ("Value"), true); EXPECT_EQ (gsi::has_class ("DoesNotExist"), false); diff --git a/src/rba/unit_tests/rba.cc b/src/rba/unit_tests/rba.cc index 2e96d4e2b..196528f1f 100644 --- a/src/rba/unit_tests/rba.cc +++ b/src/rba/unit_tests/rba.cc @@ -30,7 +30,7 @@ // windows.h is included before ruby.h ... #include "tlUnitTest.h" -TEST (1) +TEST (basic) { EXPECT_EQ (gsi::has_class ("Value"), true); EXPECT_EQ (gsi::has_class ("DoesNotExist"), false); diff --git a/testdata/python/basic.py b/testdata/python/basic.py index ec7f58ef0..0f1293f6f 100644 --- a/testdata/python/basic.py +++ b/testdata/python/basic.py @@ -412,6 +412,26 @@ class BasicTest(unittest.TestCase): self.assertEqual( a3.a1(), -11 ) self.assertEqual( a1.a10_d(5.2), "5.2" ) + self.assertEqual( a1.a10_s(0x70000000), "0" ) + self.assertEqual( a1.a10_s(0x7fffffff), "-1" ) + self.assertEqual( a1.a10_us(0x70000000), "0" ) + self.assertEqual( a1.a10_us(0x7fffffff), "65535" ) + self.assertEqual( a1.a10_i(-0x80000000), "-2147483648" ) + self.assertEqual( a1.a10_l(-0x80000000), "-2147483648" ) + self.assertEqual( a1.a10_ll(-0x80000000), "-2147483648" ) + self.assertEqual( a1.a10_ui(0xffffffff), "4294967295" ) + self.assertEqual( a1.a10_ul(0xffffffff), "4294967295" ) + self.assertEqual( a1.a10_ull(0xffffffff), "4294967295" ) + self.assertEqual( a1.a11_s(0x70000000), 0 ) + self.assertEqual( a1.a11_s(0x7fffffff), -1 ) + self.assertEqual( a1.a11_us(0x70000000), 0 ) + self.assertEqual( a1.a11_us(0x7fffffff), 65535 ) + self.assertEqual( a1.a11_i(-0x80000000), -2147483648 ) + self.assertEqual( a1.a11_l(-0x80000000), -2147483648 ) + self.assertEqual( a1.a11_ll(-0x80000000), -2147483648 ) + self.assertEqual( a1.a11_ui(0xffffffff), 4294967295 ) + self.assertEqual( a1.a11_ul(0xffffffff), 4294967295 ) + self.assertEqual( a1.a11_ull(0xffffffff), 4294967295 ) if "a10_d_qstr" in a1.__dict__: self.assertEqual( a1.a10_d_qstr(5.25), "5.25" ) self.assertEqual( a1.a10_d_qstrref(5.2), "5.2" ) diff --git a/testdata/ruby/basic_testcore.rb b/testdata/ruby/basic_testcore.rb index 8d9cd8493..ccacfe280 100644 --- a/testdata/ruby/basic_testcore.rb +++ b/testdata/ruby/basic_testcore.rb @@ -308,6 +308,27 @@ class Basic_TestClass < TestBase assert_equal( a2.a1, 11 ) assert_equal( a3.a1, -11 ) + assert_equal( a1.a10_s(0x70000000), "0" ) + assert_equal( a1.a10_s(0x7fffffff), "-1" ) + assert_equal( a1.a10_us(0x70000000), "0" ) + assert_equal( a1.a10_us(0x7fffffff), "65535" ) + assert_equal( a1.a10_i(-0x80000000), "-2147483648" ) + assert_equal( a1.a10_l(-0x80000000), "-2147483648" ) + assert_equal( a1.a10_ll(-0x80000000), "-2147483648" ) + assert_equal( a1.a10_ui(0xffffffff), "4294967295" ) + assert_equal( a1.a10_ul(0xffffffff), "4294967295" ) + assert_equal( a1.a10_ull(0xffffffff), "4294967295" ) + assert_equal( a1.a11_s(0x70000000), 0 ) + assert_equal( a1.a11_s(0x7fffffff), -1 ) + assert_equal( a1.a11_us(0x70000000), 0 ) + assert_equal( a1.a11_us(0x7fffffff), 65535 ) + assert_equal( a1.a11_i(-0x80000000), -2147483648 ) + assert_equal( a1.a11_l(-0x80000000), -2147483648 ) + assert_equal( a1.a11_ll(-0x80000000), -2147483648 ) + assert_equal( a1.a11_ui(0xffffffff), 4294967295 ) + assert_equal( a1.a11_ul(0xffffffff), 4294967295 ) + assert_equal( a1.a11_ull(0xffffffff), 4294967295 ) + assert_equal( a1.a10_d(5.2), "5.2" ) if a1.respond_to?(:a10_d_qstr) assert_equal( a1.a10_d_qstr(5.25), "5.25" )