[PyQt4] Add upstream patch (via Debian) to fix FTBFS on ARM
Peter Robinson
pbrobinson at fedoraproject.org
Sun Mar 4 09:19:27 UTC 2012
commit 4eefc758997cbe34cb8677bf47f84153625d552c
Author: Peter Robinson <pbrobinson at gmail.com>
Date: Sun Mar 4 09:19:16 2012 +0000
Add upstream patch (via Debian) to fix FTBFS on ARM
PyQt4.spec | 8 ++-
qreal_float_support.diff | 248 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 255 insertions(+), 1 deletions(-)
---
diff --git a/PyQt4.spec b/PyQt4.spec
index 6c22679..7e85bb0 100644
--- a/PyQt4.spec
+++ b/PyQt4.spec
@@ -4,7 +4,7 @@
Summary: Python bindings for Qt4
Name: PyQt4
Version: 4.9.1
-Release: 1%{?dist}
+Release: 2%{?dist}
# GPLv2 exceptions(see GPL_EXCEPTIONS*.txt)
License: GPLv3 or GPLv2 with exceptions
@@ -20,6 +20,8 @@ Patch4: PyQt-x11-gpl-4.8.3-pyuic_shbang.patch
Patch50: PyQt-x11-gpl-4.6.2-timestamp-multilib.patch
## upstream patches
+# fix FTBFS on ARM
+Patch60: qreal_float_support.diff
BuildRequires: findutils
BuildRequires: pkgconfig(dbus-1) pkgconfig(dbus-python)
@@ -100,6 +102,7 @@ from any of the Qt4 classes (e.g. KDE or your own).
%patch4 -p1
%patch50 -p1 -b .timestamp
+%patch60 -p1 -b .arm
## permissions
# mark examples non-executable
@@ -257,6 +260,9 @@ rm -rf %{buildroot}
%changelog
+* Sun Mar 4 2012 Peter Robinson <pbrobinson at fedoraproject.org> - 4.9.1-2
+- Add upstream patch (via Debian) to fix FTBFS on ARM
+
* Sat Feb 11 2012 Rex Dieter <rdieter at fedoraproject.org> 4.9.1-1
- 4.9.1
diff --git a/qreal_float_support.diff b/qreal_float_support.diff
new file mode 100644
index 0000000..af6c9cf
--- /dev/null
+++ b/qreal_float_support.diff
@@ -0,0 +1,248 @@
+## 03_qreal_float_support.dpatch by Michael Casadevall <sonicmctails at gmail.com>
+Index: python-qt4-4.9.1/configure.py
+===================================================================
+--- python-qt4-4.9.1.orig/configure.py 2012-02-11 16:59:33.402554204 -0500
++++ python-qt4-4.9.1/configure.py 2012-02-11 17:02:46.626548495 -0500
+@@ -2072,8 +2072,9 @@
+ out << "PyQt_NoOpenGLES\\n";
+ #endif
+
+- if (sizeof (qreal) != sizeof (double))
++#if defined(QT_NO_FPU) || defined(QT_ARCH_ARM) || defined(QT_ARCH_WINDOWSCE)
+ out << "PyQt_qreal_double\\n";
++#endif
+
+ return 0;
+ }
+Index: python-qt4-4.9.1/sip/QtCore/qlist.sip
+===================================================================
+--- python-qt4-4.9.1.orig/sip/QtCore/qlist.sip 2012-02-11 16:59:33.422554203 -0500
++++ python-qt4-4.9.1/sip/QtCore/qlist.sip 2012-02-11 17:05:31.546543622 -0500
+@@ -807,3 +807,227 @@
+ return sipGetState(sipTransferObj);
+ %End
+ };
++
++// If we're on an architecture where qreal != double, then we need to also
++// explicately handle doubles. On architectures where qreal == double, they
++// will automaticially be cast upwards
++
++%If (!PyQt_qreal_double)
++
++%If (Qt_4_3_0 -)
++// QList<QPair<double, double> > is implemented as a Python list of 2-element tuples.
++%MappedType QList<QPair<double, double> >
++{
++%TypeHeaderCode
++#include <qlist.h>
++#include <qpair.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ const QPair<double, double> &p = sipCpp->at(i);
++ PyObject *pobj;
++
++ if ((pobj = Py_BuildValue((char *)"dd", p.first, p.second)) == NULL)
++ {
++ Py_DECREF(l);
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ SIP_SSIZE_T len;
++
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ {
++ if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
++ return 0;
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ if (!PySequence_Check(tup) || PySequence_Size(tup) != 2)
++ return 0;
++ }
++
++ return 1;
++ }
++
++ QList<QPair<double, double> > *ql = new QList<QPair<double, double> >;
++ len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ double first = PyFloat_AsDouble(PySequence_ITEM(tup, 0));
++ double second = PyFloat_AsDouble(PySequence_ITEM(tup, 1));
++
++ ql->append(QPair<double, double>(first, second));
++ }
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++%End
++%If (Qt_4_3_0 -)
++// QList<QPair<double, TYPE> > is implemented as a Python list of 2-element tuples.
++template<double, TYPE>
++%MappedType QList<QPair<double, TYPE> >
++{
++%TypeHeaderCode
++#include <qlist.h>
++#include <qpair.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ const QPair<double, TYPE> &p = sipCpp->at(i);
++ TYPE *t = new TYPE(p.second);
++ PyObject *pobj;
++
++ if ((pobj = sipBuildResult(NULL, "(dB)", p.first, t, sipClass_TYPE, sipTransferObj)) == NULL)
++ {
++ Py_DECREF(l);
++ delete t;
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ SIP_SSIZE_T len;
++
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ {
++ if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
++ return 0;
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ if (!PySequence_Check(tup) || PySequence_Size(tup) != 2)
++ return 0;
++
++ if (!sipCanConvertToInstance(PySequence_ITEM(tup, 1), sipClass_TYPE, SIP_NOT_NONE))
++ return 0;
++ }
++
++ return 1;
++ }
++
++ QList<QPair<double, TYPE> > *ql = new QList<QPair<double, TYPE> >;
++ len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++ double d;
++ int state;
++
++ d = PyFloat_AsDouble(PySequence_ITEM(tup, 0));
++ TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PySequence_ITEM(tup, 1), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
++
++ if (*sipIsErr)
++ {
++ sipReleaseInstance(t, sipClass_TYPE, state);
++
++ delete ql;
++ return 0;
++ }
++
++ ql->append(QPair<double, TYPE>(d, *t));
++
++ sipReleaseInstance(t, sipClass_TYPE, state);
++ }
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++%End
++
++// QList<double> is implemented as a Python list of doubles.
++%MappedType QList<double>
++{
++%TypeHeaderCode
++#include <qlist.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ PyObject *pobj;
++
++ if ((pobj = PyFloat_FromDouble(sipCpp->value(i))) == NULL)
++ {
++ Py_DECREF(l);
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ return (PySequence_Check(sipPy) && PySequence_Size(sipPy) >= 0);
++
++ QList<double> *ql = new QList<double>;
++ SIP_SSIZE_T len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ ql->append(PyFloat_AsDouble(PySequence_ITEM(sipPy, i)));
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++
++%End
More information about the scm-commits
mailing list