Attachment 180362 Details for Bug 217424 – patch

[patch] patch

devel_py-qt4-core.diff (text/plain), 6.54 KB, created by Mikael Urankar on 2017-02-28 17:43:03 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mikael Urankar

Created: 2017-02-28 17:43:03 UTC

Size: 6.54 KB

patch

obsolete

>Index: Makefile
>===================================================================
>--- Makefile	(revision 434403)
>+++ Makefile	(working copy)
>@@ -2,6 +2,7 @@
> # $FreeBSD$
> 
> PORTNAME=	core
>+PORTREVISION=	1
> PORTEPOCH=	1
> CATEGORIES=	devel python
> 
>Index: files/patch-sip_QtCore_qlist.sip
>===================================================================
>--- files/patch-sip_QtCore_qlist.sip	(nonexistent)
>+++ files/patch-sip_QtCore_qlist.sip	(working copy)
>@@ -0,0 +1,233 @@
>+--- sip/QtCore/qlist.sip.orig	2015-06-11 17:28:22 UTC
>++++ sip/QtCore/qlist.sip
>+@@ -748,6 +748,230 @@ template<qreal, TYPE>
>+     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
>+ // QList<qreal> is implemented as a Python list of floats.
>+ %MappedType QList<qreal> /DocType="list-of-float"/
>+ {
>
>Property changes on: files/patch-sip_QtCore_qlist.sip
>___________________________________________________________________
>Added: fbsd:nokeywords
>## -0,0 +1 ##
>+yes
>\ No newline at end of property
>Added: svn:eol-style
>## -0,0 +1 ##
>+native
>\ No newline at end of property
>Added: svn:mime-type
>## -0,0 +1 ##
>+text/plain
>\ No newline at end of property

Actions: View | Diff

Attachments on bug 217424: 180362