From 380c65e62de0e60da667dc0d87935171b91b9c6c Mon Sep 17 00:00:00 2001 From: Christian Tismer Date: Sun, 16 Jun 2019 12:05:39 +0200 Subject: Cleanup pointer whitespace everywhere Among other files to fix, basewrapper.(cpp|h) was full of uncommon pointer whitespace. After fixing that, I could not resist and fixed also libshiboken, generators, and after acceptance also PySide. Most of the time, this regex worked fine (\w\w+)([*&]+)[ ]*(?![&*]*[/=]) replaced with \1 \2 but everything was checked by hand. I did not touch the shiboken tests which are quite hairy. It turned out that inserting a space between a variable and asterisk causes a crash of shiboken, if the same line contains "CONVERTTOCPP". This was temporarily fixed by adding another space after it. Example.. sources/pyside2/PySide2/glue/qtcore.cpp line 977 QByteArray * cppSelf = %CONVERTTOCPP[QByteArray *](obj); //XXX /|\ omitting this space crashes shiboken! cppgenerator.cpp was special, since it was modified to _generate_ correct pointer whitespace. This caused a few testcases to fail, which had to be adjusted, again. This was difficult since some internal names must end on "*" and generated code normally not. Removing the last errors involved binary search on path sets... Apply C++ 11 fixits to the changed code, where applicable. Done-with: Friedemann.Kleint@qt.io Task-number: PYSIDE-1037 Change-Id: I4ac070f52c5efb296c05d581c9d46e6f397a6c81 Reviewed-by: Qt CI Bot Reviewed-by: Friedemann Kleint --- .../PySide2/QtCore/glue/qeasingcurve_glue.cpp | 22 +- .../PySide2/QtCore/glue/qeasingcurve_glue.h | 14 +- .../PySide2/QtQml/pysideqmlregistertype.cpp | 70 +- .../pyside2/PySide2/QtQml/pysideqmlregistertype.h | 4 +- .../PySide2/QtQuick/pysidequickregistertype.cpp | 6 +- .../QtScript/qscript_value_iterator_glue.cpp | 2 +- sources/pyside2/PySide2/QtUiTools/glue/plugins.h | 9 +- sources/pyside2/PySide2/glue/qtcore.cpp | 207 +++--- sources/pyside2/PySide2/glue/qtgui.cpp | 20 +- sources/pyside2/PySide2/glue/qtmultimedia.cpp | 3 +- sources/pyside2/PySide2/glue/qtopengl.cpp | 8 +- sources/pyside2/PySide2/glue/qtscript.cpp | 2 +- sources/pyside2/PySide2/glue/qtuitools.cpp | 14 +- sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp | 4 +- sources/pyside2/PySide2/glue/qtwidgets.cpp | 201 +++--- sources/pyside2/PySide2/glue/qtxml.cpp | 4 +- sources/pyside2/PySide2/glue/qtxmlpatterns.cpp | 4 +- sources/pyside2/PySide2/pysideqtesttouch.h | 22 +- sources/pyside2/PySide2/qpytextobject.h | 7 +- sources/pyside2/libpyside/destroylistener.cpp | 12 +- sources/pyside2/libpyside/destroylistener.h | 10 +- sources/pyside2/libpyside/globalreceiverv2.cpp | 52 +- sources/pyside2/libpyside/globalreceiverv2.h | 16 +- sources/pyside2/libpyside/pyside.cpp | 88 +-- sources/pyside2/libpyside/pyside.h | 20 +- sources/pyside2/libpyside/pysideclassinfo.cpp | 36 +- sources/pyside2/libpyside/pysidemetafunction.cpp | 30 +- sources/pyside2/libpyside/pysidemetafunction.h | 4 +- sources/pyside2/libpyside/pysidemetafunction_p.h | 4 +- sources/pyside2/libpyside/pysideproperty.cpp | 127 ++-- sources/pyside2/libpyside/pysideqflags.cpp | 26 +- sources/pyside2/libpyside/pysidesignal.cpp | 224 +++---- sources/pyside2/libpyside/pysideslot.cpp | 24 +- sources/pyside2/libpyside/pysideweakref.cpp | 14 +- sources/pyside2/libpyside/signalmanager.cpp | 132 ++-- sources/pyside2/plugins/customwidget.cpp | 20 +- sources/pyside2/plugins/customwidgets.cpp | 11 +- sources/pyside2/tests/pysidetest/hiddenobject.cpp | 2 +- .../shiboken2/ApiExtractor/abstractmetabuilder.cpp | 68 +- .../shiboken2/ApiExtractor/abstractmetalang.cpp | 22 +- sources/shiboken2/ApiExtractor/typedatabase.h | 58 +- sources/shiboken2/generator/generator.cpp | 72 +- sources/shiboken2/generator/generator.h | 64 +- sources/shiboken2/generator/main.cpp | 6 +- .../shiboken2/generator/shiboken2/cppgenerator.cpp | 744 ++++++++++----------- .../shiboken2/generator/shiboken2/cppgenerator.h | 192 +++--- .../generator/shiboken2/headergenerator.cpp | 72 +- .../generator/shiboken2/headergenerator.h | 22 +- .../shiboken2/generator/shiboken2/overloaddata.cpp | 94 +-- .../shiboken2/generator/shiboken2/overloaddata.h | 58 +- .../generator/shiboken2/shibokengenerator.cpp | 326 ++++----- .../generator/shiboken2/shibokengenerator.h | 274 ++++---- sources/shiboken2/libshiboken/autodecref.h | 24 +- sources/shiboken2/libshiboken/basewrapper.cpp | 322 ++++----- sources/shiboken2/libshiboken/basewrapper.h | 154 ++--- sources/shiboken2/libshiboken/basewrapper_p.h | 36 +- sources/shiboken2/libshiboken/bindingmanager.cpp | 84 +-- sources/shiboken2/libshiboken/bindingmanager.h | 34 +- sources/shiboken2/libshiboken/bufferprocs_py37.cpp | 11 +- sources/shiboken2/libshiboken/debugfreehook.cpp | 8 +- sources/shiboken2/libshiboken/gilstate.h | 8 +- sources/shiboken2/libshiboken/helper.cpp | 24 +- sources/shiboken2/libshiboken/helper.h | 20 +- .../shiboken2/libshiboken/pep384_issue33738.cpp | 2 +- sources/shiboken2/libshiboken/pep384impl.cpp | 4 +- sources/shiboken2/libshiboken/python25compat.h | 8 +- sources/shiboken2/libshiboken/sbkarrayconverter.h | 6 +- .../shiboken2/libshiboken/sbkarrayconverter_p.h | 2 +- sources/shiboken2/libshiboken/sbkconverter.cpp | 78 +-- sources/shiboken2/libshiboken/sbkconverter.h | 148 ++-- sources/shiboken2/libshiboken/sbkconverter_p.h | 140 ++-- sources/shiboken2/libshiboken/sbkdbg.h | 32 +- sources/shiboken2/libshiboken/sbkenum.cpp | 150 ++--- sources/shiboken2/libshiboken/sbkenum.h | 42 +- sources/shiboken2/libshiboken/sbkmodule.cpp | 18 +- sources/shiboken2/libshiboken/sbkmodule.h | 24 +- sources/shiboken2/libshiboken/sbkstring.cpp | 34 +- sources/shiboken2/libshiboken/sbkstring.h | 24 +- sources/shiboken2/libshiboken/shibokenbuffer.cpp | 14 +- sources/shiboken2/libshiboken/shibokenbuffer.h | 8 +- sources/shiboken2/libshiboken/signature.cpp | 4 +- sources/shiboken2/libshiboken/threadstatesaver.h | 10 +- .../tmp-referencetopython/sbkconverter.cpp | 59 +- .../tmp-referencetopython/sbkconverter.h | 46 +- sources/shiboken2/libshiboken/typespec.cpp | 15 +- sources/shiboken2/libshiboken/typespec.h | 8 +- sources/shiboken2/libshiboken/voidptr.cpp | 8 +- 87 files changed, 2580 insertions(+), 2576 deletions(-) diff --git a/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.cpp b/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.cpp index 46a69be31..6629d3c91 100644 --- a/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.cpp +++ b/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.cpp @@ -47,13 +47,13 @@ #define __ECF_ATT_NAME__ "__ecf__" #define MAX_CUSTOM_FUNCTIONS 10 -static void deleteData(void* data); +static void deleteData(void *data); struct CustomFunctionsData { static CustomFunctionsData m_list[MAX_CUSTOM_FUNCTIONS]; - PySideEasingCurveFunctor* m_obj; + PySideEasingCurveFunctor *m_obj; QEasingCurve::EasingFunction m_func; }; @@ -95,9 +95,9 @@ struct CustomFunctions<0> } }; -void deleteData(void* data) +void deleteData(void *data) { - delete (PySideEasingCurveFunctor*)(data); + delete (PySideEasingCurveFunctor *)(data); } void PySideEasingCurveFunctor::init() @@ -105,10 +105,10 @@ void PySideEasingCurveFunctor::init() CustomFunctions::init(); } -QEasingCurve::EasingFunction PySideEasingCurveFunctor::createCustomFuntion(PyObject* parent, PyObject* pyFunc) +QEasingCurve::EasingFunction PySideEasingCurveFunctor::createCustomFuntion(PyObject *parent, PyObject *pyFunc) { for(int i=0; i < MAX_CUSTOM_FUNCTIONS; i++) { - CustomFunctionsData& data = CustomFunctionsData::m_list[i]; + CustomFunctionsData &data = CustomFunctionsData::m_list[i]; if (data.m_obj == 0) { data.m_obj = new PySideEasingCurveFunctor(i, parent, pyFunc); return data.m_func; @@ -128,8 +128,8 @@ PySideEasingCurveFunctor::~PySideEasingCurveFunctor() qreal PySideEasingCurveFunctor::operator()(qreal progress) { Shiboken::GilState state; - PyObject* args = Py_BuildValue("(f)", progress); - PyObject* result = PyObject_CallObject(m_func, args); + PyObject *args = Py_BuildValue("(f)", progress); + PyObject *result = PyObject_CallObject(m_func, args); qreal cppResult = 0.0; if (result) { Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter(), result, &cppResult); @@ -139,18 +139,18 @@ qreal PySideEasingCurveFunctor::operator()(qreal progress) return cppResult; } -PyObject* PySideEasingCurveFunctor::callable() +PyObject *PySideEasingCurveFunctor::callable() { Py_INCREF(m_func); return m_func; } -PyObject* PySideEasingCurveFunctor::callable(PyObject* parent) +PyObject *PySideEasingCurveFunctor::callable(PyObject *parent) { return PyObject_GetAttrString(parent, __ECF_ATT_NAME__); } -PySideEasingCurveFunctor::PySideEasingCurveFunctor(int index, PyObject* parent, PyObject* pyFunc) +PySideEasingCurveFunctor::PySideEasingCurveFunctor(int index, PyObject *parent, PyObject *pyFunc) : m_parent(parent), m_func(pyFunc), m_index(index) { PyObject_SetAttrString(m_parent, __ECF_ATT_NAME__, m_func); diff --git a/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.h b/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.h index 358ea9eec..f6c80fa99 100644 --- a/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.h +++ b/sources/pyside2/PySide2/QtCore/glue/qeasingcurve_glue.h @@ -38,7 +38,7 @@ ****************************************************************************/ #ifndef __QEASINGCURVE_GLUE__ -#define __QEASINGCURVE_GLUE__ +#define __QEASINGCURVE_GLUE__ #include #include @@ -47,20 +47,20 @@ class PySideEasingCurveFunctor { public: static void init(); - static QEasingCurve::EasingFunction createCustomFuntion(PyObject* parent, PyObject* pyFunc); + static QEasingCurve::EasingFunction createCustomFuntion(PyObject *parent, PyObject *pyFunc); qreal operator()(qreal progress); - PyObject* callable(); //Return New reference - static PyObject* callable(PyObject* parent); //Return New reference + PyObject *callable(); //Return New reference + static PyObject *callable(PyObject *parent); //Return New reference ~PySideEasingCurveFunctor(); private: - PyObject* m_parent; - PyObject* m_func; + PyObject *m_parent; + PyObject *m_func; int m_index; - PySideEasingCurveFunctor(int index, PyObject* parent, PyObject *pyFunc); + PySideEasingCurveFunctor(int index, PyObject *parent, PyObject *pyFunc); }; #endif diff --git a/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.cpp b/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.cpp index 9d9ddc799..2386620ca 100644 --- a/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.cpp +++ b/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.cpp @@ -54,19 +54,19 @@ #ifndef PYSIDE_MAX_QML_TYPES // Maximum number of different Qt QML types the user can export to QML using // qmlRegisterType. This limit exists because the QML engine instantiates objects -// by calling a function with one argument (a void* pointer where the object should +// by calling a function with one argument (a void *pointer where the object should // be created), and thus does not allow us to choose which object to create. Thus // we create a C++ factory function for each new registered type at compile time. #define PYSIDE_MAX_QML_TYPES 50 #endif // Forward declarations. -static void propListMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Call call, +static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, void **args); // All registered python types and their creation functions. -static PyObject* pyTypes[PYSIDE_MAX_QML_TYPES]; -static void (*createFuncs[PYSIDE_MAX_QML_TYPES])(void*); +static PyObject *pyTypes[PYSIDE_MAX_QML_TYPES]; +static void (*createFuncs[PYSIDE_MAX_QML_TYPES])(void *); // Mutex used to avoid race condition on PySide::nextQObjectMemoryAddr. static QMutex nextQmlElementMutex; @@ -74,12 +74,12 @@ static QMutex nextQmlElementMutex; template struct ElementFactoryBase { - static void createInto(void* memory) + static void createInto(void *memory) { QMutexLocker locker(&nextQmlElementMutex); PySide::setNextQObjectMemoryAddr(memory); Shiboken::GilState state; - PyObject* obj = PyObject_CallObject(pyTypes[N], 0); + PyObject *obj = PyObject_CallObject(pyTypes[N], 0); if (!obj || PyErr_Occurred()) PyErr_Print(); PySide::setNextQObjectMemoryAddr(0); @@ -152,7 +152,7 @@ int PySide::qmlRegisterType(PyObject *pyObj, const char *uri, int versionMajor, pyTypes[nextType] = pyObj; // FIXME: Fix this to assign new type ids each time. - type.typeId = qMetaTypeId(); + type.typeId = qMetaTypeId(); type.listId = qMetaTypeId >(); type.attachedPropertiesFunction = QQmlPrivate::attachedPropertiesFunc(); type.attachedPropertiesMetaObject = QQmlPrivate::attachedPropertiesMetaObject(); @@ -194,22 +194,22 @@ extern "C" // This is the user data we store in the property. struct QmlListProperty { - PyTypeObject* type; - PyObject* append; - PyObject* at; - PyObject* clear; - PyObject* count; + PyTypeObject *type; + PyObject *append; + PyObject *at; + PyObject *clear; + PyObject *count; }; -static int propListTpInit(PyObject* self, PyObject* args, PyObject* kwds) +static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds) { static const char *kwlist[] = {"type", "append", "at", "clear", "count", 0}; - PySideProperty* pySelf = reinterpret_cast(self); - QmlListProperty* data = new QmlListProperty; + PySideProperty *pySelf = reinterpret_cast(self); + QmlListProperty *data = new QmlListProperty; memset(data, 0, sizeof(QmlListProperty)); if (!PyArg_ParseTupleAndKeywords(args, kwds, - "OO|OOO:QtQml.ListProperty", (char**) kwlist, + "OO|OOO:QtQml.ListProperty", (char **) kwlist, &data->type, &data->append, &data->at, @@ -224,10 +224,10 @@ static int propListTpInit(PyObject* self, PyObject* args, PyObject* kwds) return 1; } -void propListTpFree(void* self) +void propListTpFree(void *self) { - PySideProperty* pySelf = reinterpret_cast(self); - delete reinterpret_cast(PySide::Property::userData(pySelf)); + auto pySelf = reinterpret_cast(self); + delete reinterpret_cast(PySide::Property::userData(pySelf)); // calls base type constructor Py_TYPE(pySelf)->tp_base->tp_free(self); } @@ -266,10 +266,10 @@ void propListAppender(QQmlListProperty *propList, QObject *item) Shiboken::GilState state; Shiboken::AutoDecRef args(PyTuple_New(2)); - PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); - PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], item)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::pointerToPython((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], item)); - QmlListProperty* data = reinterpret_cast(propList->data); + auto data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->append, args)); if (PyErr_Occurred()) @@ -282,9 +282,9 @@ int propListCount(QQmlListProperty *propList) Shiboken::GilState state; Shiboken::AutoDecRef args(PyTuple_New(1)); - PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); - QmlListProperty* data = reinterpret_cast(propList->data); + auto data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->count, args)); // Check return type @@ -303,17 +303,17 @@ QObject *propListAt(QQmlListProperty *propList, int index) Shiboken::GilState state; Shiboken::AutoDecRef args(PyTuple_New(2)); - PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &index)); - QmlListProperty* data = reinterpret_cast(propList->data); + auto data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->at, args)); QObject *result = 0; if (PyErr_Occurred()) PyErr_Print(); else if (PyType_IsSubtype(Py_TYPE(retVal), data->type)) - Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], retVal, &result); + Shiboken::Conversions::pythonToCppPointer((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], retVal, &result); return result; } @@ -323,9 +323,9 @@ void propListClear(QQmlListProperty * propList) Shiboken::GilState state; Shiboken::AutoDecRef args(PyTuple_New(1)); - PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); - QmlListProperty* data = reinterpret_cast(propList->data); + auto data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->clear, args)); if (PyErr_Occurred()) @@ -333,18 +333,18 @@ void propListClear(QQmlListProperty * propList) } // qt_metacall specialization for ListProperties -static void propListMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Call call, void** args) +static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, void **args) { if (call != QMetaObject::ReadProperty) return; - QmlListProperty* data = reinterpret_cast(PySide::Property::userData(pp)); - QObject* qobj; - Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], self, &qobj); + auto data = reinterpret_cast(PySide::Property::userData(pp)); + QObject *qobj; + Shiboken::Conversions::pythonToCppPointer((SbkObjectType *)SbkPySide2_QtCoreTypes[SBK_QOBJECT_IDX], self, &qobj); QQmlListProperty declProp(qobj, data, &propListAppender, &propListCount, &propListAt, &propListClear); // Copy the data to the memory location requested by the meta call - void* v = args[0]; + void *v = args[0]; *reinterpret_cast *>(v) = declProp; } @@ -469,7 +469,7 @@ PyTypeObject *QtQml_VolatileBoolTypeF(void) return type; } -void PySide::initQmlSupport(PyObject* module) +void PySide::initQmlSupport(PyObject *module) { ElementFactory::init(); diff --git a/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.h b/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.h index 0ef6539a5..e94ea043f 100644 --- a/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.h +++ b/sources/pyside2/PySide2/QtQml/pysideqmlregistertype.h @@ -47,7 +47,7 @@ struct SbkObjectType; namespace PySide { -extern void* nextQmlElementMemoryAddr; +extern void *nextQmlElementMemoryAddr; /** * Init the QML support doing things like registering QtQml.ListProperty and create the necessary stuff for @@ -55,7 +55,7 @@ extern void* nextQmlElementMemoryAddr; * * \param module QtQml python module */ -void initQmlSupport(PyObject* module); +void initQmlSupport(PyObject *module); /** * PySide implementation of qmlRegisterType function. diff --git a/sources/pyside2/PySide2/QtQuick/pysidequickregistertype.cpp b/sources/pyside2/PySide2/QtQuick/pysidequickregistertype.cpp index e50b1dfc7..7278edff3 100644 --- a/sources/pyside2/PySide2/QtQuick/pysidequickregistertype.cpp +++ b/sources/pyside2/PySide2/QtQuick/pysidequickregistertype.cpp @@ -62,7 +62,7 @@ // All registered python types and their creation functions. static PyObject *pyTypes[PYSIDE_MAX_QUICK_TYPES]; -static void (*createFuncs[PYSIDE_MAX_QUICK_TYPES])(void*); +static void (*createFuncs[PYSIDE_MAX_QUICK_TYPES])(void *); // Mutex used to avoid race condition on PySide::nextQObjectMemoryAddr. static QMutex nextQmlElementMutex; @@ -153,8 +153,8 @@ void registerTypeIfInheritsFromClass( ::Construct, sizeof(QQmlListProperty), static_cast< ::QFlags >( - QtPrivate::QMetaTypeTypeFlags >::Flags), - static_cast(0)); + QtPrivate::QMetaTypeTypeFlags >::Flags), + nullptr); if (lstType == -1) { PyErr_Format(PyExc_TypeError, "Meta type registration of \"%s\" for QML usage failed.", typeListName.constData()); diff --git a/sources/pyside2/PySide2/QtScript/qscript_value_iterator_glue.cpp b/sources/pyside2/PySide2/QtScript/qscript_value_iterator_glue.cpp index fd9cd84a3..11dfd19b0 100644 --- a/sources/pyside2/PySide2/QtScript/qscript_value_iterator_glue.cpp +++ b/sources/pyside2/PySide2/QtScript/qscript_value_iterator_glue.cpp @@ -1,3 +1,3 @@ %PYARG_0 = Shiboken::Object::newObject( - reinterpret_cast(Shiboken::SbkType< ::QScriptValueIterator >()), + reinterpret_cast(Shiboken::SbkType< ::QScriptValueIterator >()), new QScriptValueIterator(*%CPPSELF), true, true); diff --git a/sources/pyside2/PySide2/QtUiTools/glue/plugins.h b/sources/pyside2/PySide2/QtUiTools/glue/plugins.h index d1b250d50..9bfcec6ea 100644 --- a/sources/pyside2/PySide2/QtUiTools/glue/plugins.h +++ b/sources/pyside2/PySide2/QtUiTools/glue/plugins.h @@ -43,13 +43,14 @@ #include #include "customwidgets.h" -inline void registerCustomWidget(PyObject* obj) +inline void registerCustomWidget(PyObject *obj) { - static PyCustomWidgets* plugin = 0; + static PyCustomWidgets *plugin = nullptr; if (plugin == 0) { - foreach(QObject* o, QPluginLoader::staticInstances()) { - plugin = qobject_cast(o); + const auto &instances = QPluginLoader::staticInstances(); + for (QObject *o : instances) { + plugin = qobject_cast(o); if (plugin) break; } diff --git a/sources/pyside2/PySide2/glue/qtcore.cpp b/sources/pyside2/PySide2/glue/qtcore.cpp index 9db4e2e82..cb5cb4e68 100644 --- a/sources/pyside2/PySide2/glue/qtcore.cpp +++ b/sources/pyside2/PySide2/glue/qtcore.cpp @@ -60,8 +60,8 @@ bool py2kStrCheck(PyObject *obj) static const char *QVariant_resolveMetaType(PyTypeObject *type, int *typeId) { if (PyObject_TypeCheck(type, SbkObjectType_TypeF())) { - SbkObjectType* sbkType = (SbkObjectType*)type; - const char* typeName = Shiboken::ObjectType::getOriginalName(sbkType); + auto sbkType = reinterpret_cast(type); + const char *typeName = Shiboken::ObjectType::getOriginalName(sbkType); if (!typeName) return nullptr; const bool valueType = '*' != typeName[qstrlen(typeName) - 1]; @@ -105,7 +105,7 @@ static QVariant QVariant_convertToValueList(PyObject *list) Shiboken::AutoDecRef element(PySequence_GetItem(list, 0)); int typeId; - const char *typeName = QVariant_resolveMetaType(element.cast(), &typeId); + const char *typeName = QVariant_resolveMetaType(element.cast(), &typeId); if (typeName) { QByteArray listTypeName("QList<"); listTypeName += typeName; @@ -220,7 +220,7 @@ double _abs = qAbs(%1); // @snippet qt-postroutine namespace PySide { -static QStack globalPostRoutineFunctions; +static QStack globalPostRoutineFunctions; void globalPostRoutineCallback() { Shiboken::GilState state; @@ -260,7 +260,7 @@ PyModule_AddStringConstant(module, "__version__", qVersion()); // @snippet qt-version // @snippet qobject-connect -static bool isDecorator(PyObject* method, PyObject* self) +static bool isDecorator(PyObject *method, PyObject *self) { Shiboken::AutoDecRef methodName(PyObject_GetAttrString(method, "__name__")); if (!PyObject_HasAttr(self, methodName)) @@ -269,18 +269,18 @@ static bool isDecorator(PyObject* method, PyObject* self) return PyMethod_GET_FUNCTION(otherMethod.object()) != PyMethod_GET_FUNCTION(method); } -static bool getReceiver(QObject *source, const char* signal, PyObject* callback, QObject** receiver, PyObject** self, QByteArray* callbackSig) +static bool getReceiver(QObject *source, const char *signal, PyObject *callback, QObject **receiver, PyObject **self, QByteArray *callbackSig) { bool forceGlobalReceiver = false; if (PyMethod_Check(callback)) { *self = PyMethod_GET_SELF(callback); - if (%CHECKTYPE[QObject*](*self)) - *receiver = %CONVERTTOCPP[QObject*](*self); + if (%CHECKTYPE[QObject *](*self)) + *receiver = %CONVERTTOCPP[QObject *](*self); forceGlobalReceiver = isDecorator(callback, *self); } else if (PyCFunction_Check(callback)) { *self = PyCFunction_GET_SELF(callback); - if (*self && %CHECKTYPE[QObject*](*self)) - *receiver = %CONVERTTOCPP[QObject*](*self); + if (*self && %CHECKTYPE[QObject *](*self)) + *receiver = %CONVERTTOCPP[QObject *](*self); } else if (PyCallable_Check(callback)) { // Ok, just a callable object *receiver = nullptr; @@ -292,14 +292,14 @@ static bool getReceiver(QObject *source, const char* signal, PyObject* callback, // Check if this callback is a overwrite of a non-virtual Qt slot. if (!usingGlobalReceiver && receiver && self) { *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toLatin1(); - const QMetaObject* metaObject = (*receiver)->metaObject(); + const QMetaObject *metaObject = (*receiver)->metaObject(); int slotIndex = metaObject->indexOfSlot(callbackSig->constData()); if (slotIndex != -1 && slotIndex < metaObject->methodOffset() && PyMethod_Check(callback)) usingGlobalReceiver = true; } if (usingGlobalReceiver) { - PySide::SignalManager& signalManager = PySide::SignalManager::instance(); + PySide::SignalManager &signalManager = PySide::SignalManager::instance(); *receiver = signalManager.globalReceiver(source, callback); *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toLatin1(); } @@ -307,7 +307,7 @@ static bool getReceiver(QObject *source, const char* signal, PyObject* callback, return usingGlobalReceiver; } -static bool qobjectConnect(QObject* source, const char* signal, QObject* receiver, const char* slot, Qt::ConnectionType type) +static bool qobjectConnect(QObject *source, const char *signal, QObject *receiver, const char *slot, Qt::ConnectionType type) { if (!signal || !slot) return false; @@ -329,12 +329,12 @@ static bool qobjectConnect(QObject* source, const char* signal, QObject* receive return connection; } -static bool qobjectConnect(QObject* source, QMetaMethod signal, QObject* receiver, QMetaMethod slot, Qt::ConnectionType type) +static bool qobjectConnect(QObject *source, QMetaMethod signal, QObject *receiver, QMetaMethod slot, Qt::ConnectionType type) { return qobjectConnect(source, signal.methodSignature(), receiver, slot.methodSignature(), type); } -static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject* callback, Qt::ConnectionType type) +static bool qobjectConnectCallback(QObject *source, const char *signal, PyObject *callback, Qt::ConnectionType type) { if (!signal || !PySide::Signal::checkQtSignal(signal)) return false; @@ -344,23 +344,23 @@ static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject if (signalIndex == -1) return false; - PySide::SignalManager& signalManager = PySide::SignalManager::instance(); + PySide::SignalManager &signalManager = PySide::SignalManager::instance(); // Extract receiver from callback - QObject* receiver = nullptr; - PyObject* self = nullptr; + QObject *receiver = nullptr; + PyObject *self = nullptr; QByteArray callbackSig; bool usingGlobalReceiver = getReceiver(source, signal, callback, &receiver, &self, &callbackSig); if (receiver == nullptr && self == nullptr) return false; - const QMetaObject* metaObject = receiver->metaObject(); - const char* slot = callbackSig.constData(); + const QMetaObject *metaObject = receiver->metaObject(); + const char *slot = callbackSig.constData(); int slotIndex = metaObject->indexOfSlot(slot); QMetaMethod signalMethod = metaObject->method(signalIndex); if (slotIndex == -1) { - if (!usingGlobalReceiver && self && !Shiboken::Object::hasCppWrapper((SbkObject*)self)) { + if (!usingGlobalReceiver && self && !Shiboken::Object::hasCppWrapper(reinterpret_cast(self))) { qWarning("You can't add dynamic slots on an object originated from C++."); if (usingGlobalReceiver) signalManager.releaseGlobalReceiver(source, receiver); @@ -388,11 +388,11 @@ static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject if (usingGlobalReceiver) signalManager.notifyGlobalReceiver(receiver); #ifndef AVOID_PROTECTED_HACK - source->connectNotify(signalMethod); //Qt5: QMetaMethod instead of char* + source->connectNotify(signalMethod); //Qt5: QMetaMethod instead of char * #else - // Need to cast to QObjectWrapper* and call the public version of + // Need to cast to QObjectWrapper * and call the public version of // connectNotify when avoiding the protected hack. - reinterpret_cast(source)->connectNotify(signalMethod); //Qt5: QMetaMethod instead of char* + reinterpret_cast(source)->connectNotify(signalMethod); //Qt5: QMetaMethod instead of char * #endif return connection; @@ -405,23 +405,23 @@ static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject } -static bool qobjectDisconnectCallback(QObject* source, const char* signal, PyObject* callback) +static bool qobjectDisconnectCallback(QObject *source, const char *signal, PyObject *callback) { if (!PySide::Signal::checkQtSignal(signal)) return false; - PySide::SignalManager& signalManager = PySide::SignalManager::instance(); + PySide::SignalManager &signalManager = PySide::SignalManager::instance(); // Extract receiver from callback - QObject* receiver = nullptr; - PyObject* self = nullptr; + QObject *receiver = nullptr; + PyObject *self = nullptr; QByteArray callbackSig; QMetaMethod slotMethod; bool usingGlobalReceiver = getReceiver(nullptr, signal, callback, &receiver, &self, &callbackSig); if (receiver == nullptr && self == nullptr) return false; - const QMetaObject* metaObject = receiver->metaObject(); + const QMetaObject *metaObject = receiver->metaObject(); int signalIndex = source->metaObject()->indexOfSignal(++signal); int slotIndex = -1; @@ -438,11 +438,11 @@ static bool qobjectDisconnectCallback(QObject* source, const char* signal, PyObj signalManager.releaseGlobalReceiver(source, receiver); #ifndef AVOID_PROTECTED_HACK - source->disconnectNotify(slotMethod); //Qt5: QMetaMethod instead of char* + source->disconnectNotify(slotMethod); //Qt5: QMetaMethod instead of char * #else - // Need to cast to QObjectWrapper* and call the public version of + // Need to cast to QObjectWrapper * and call the public version of // connectNotify when avoiding the protected hack. - reinterpret_cast(source)->disconnectNotify(slotMethod); //Qt5: QMetaMethod instead of char* + reinterpret_cast(source)->disconnectNotify(slotMethod); //Qt5: QMetaMethod instead of char * #endif return true; } @@ -706,10 +706,10 @@ qRegisterMetaType >("QVector"); // @snippet qobject-metaobject // @snippet qobject-findchild-1 -static QObject* _findChildHelper(const QObject* parent, const QString& name, PyTypeObject* desiredType) +static QObject *_findChildHelper(const QObject *parent, const QString &name, PyTypeObject *desiredType) { for (auto *child : parent->children()) { - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject*](child)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject *](child)); if (PyType_IsSubtype(Py_TYPE(pyChild), desiredType) && (name.isNull() || name == child->objectName())) { return child; @@ -724,21 +724,21 @@ static QObject* _findChildHelper(const QObject* parent, const QString& name, PyT return nullptr; } -static inline bool _findChildrenComparator(const QObject*& child, const QRegExp& name) +static inline bool _findChildrenComparator(const QObject *&child, const QRegExp &name) { return name.indexIn(child->objectName()) != -1; } -static inline bool _findChildrenComparator(const QObject*& child, const QString& name) +static inline bool _findChildrenComparator(const QObject *&child, const QString &name) { return name.isNull() || name == child->objectName(); } template -static void _findChildrenHelper(const QObject* parent, const T& name, PyTypeObject* desiredType, PyObject* result) +static void _findChildrenHelper(const QObject *parent, const T& name, PyTypeObject *desiredType, PyObject *result) { for (const auto *child : parent->children()) { - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject*](child)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject *](child)); if (PyType_IsSubtype(Py_TYPE(pyChild), desiredType) && _findChildrenComparator(child, name)) PyList_Append(result, pyChild); _findChildrenHelper(child, name, desiredType, result); @@ -747,18 +747,18 @@ static void _findChildrenHelper(const QObject* parent, const T& name, PyTypeObje // @snippet qobject-findchild-1 // @snippet qobject-findchild-2 -QObject *child = _findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1); -%PYARG_0 = %CONVERTTOPYTHON[QObject*](child); +QObject *child = _findChildHelper(%CPPSELF, %2, reinterpret_cast(%PYARG_1)); +%PYARG_0 = %CONVERTTOPYTHON[QObject *](child); // @snippet qobject-findchild-2 // @snippet qobject-findchildren-1 %PYARG_0 = PyList_New(0); -_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0); +_findChildrenHelper(%CPPSELF, %2, reinterpret_cast(%PYARG_1), %PYARG_0); // @snippet qobject-findchildren-1 // @snippet qobject-findchildren-2 %PYARG_0 = PyList_New(0); -_findChildrenHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1, %PYARG_0); +_findChildrenHelper(%CPPSELF, %2, reinterpret_cast(%PYARG_1), %PYARG_0); // @snippet qobject-findchildren-2 // @snippet qobject-tr @@ -942,8 +942,7 @@ if (PyIndex_Check(_key)) { int overflow; long ival = PyLong_AsLongAndOverflow(item, &overflow); // Not suppose to bigger than 255 because only bytes, bytearray, QByteArray were accept - const char *el = reinterpret_cast(&ival); - temp = QByteArray(el); + temp = QByteArray(reinterpret_cast(&ival)); } else { temp = %CONVERTTOCPP[QByteArray](item); } @@ -969,18 +968,19 @@ extern "C" { // QByteArray buffer protocol functions // see: http://www.python.org/dev/peps/pep-3118/ -static int SbkQByteArray_getbufferproc(PyObject* obj, Py_buffer *view, int flags) +static int SbkQByteArray_getbufferproc(PyObject *obj, Py_buffer *view, int flags) { if (!view || !Shiboken::Object::isValid(obj)) return -1; - QByteArray* cppSelf = %CONVERTTOCPP[QByteArray*](obj); + QByteArray * cppSelf = %CONVERTTOCPP[QByteArray *](obj); + //XXX /|\ omitting this space crashes shiboken! view->obj = obj; - view->buf = reinterpret_cast(cppSelf->data()); + view->buf = reinterpret_cast(cppSelf->data()); view->len = cppSelf->size(); view->readonly = 0; view->itemsize = 1; - view->format = const_cast("c"); + view->format = const_cast("c"); view->ndim = 1; view->shape = NULL; view->strides = &view->itemsize; @@ -992,20 +992,21 @@ static int SbkQByteArray_getbufferproc(PyObject* obj, Py_buffer *view, int flags } #if PY_VERSION_HEX < 0x03000000 -static Py_ssize_t SbkQByteArray_segcountproc(PyObject* self, Py_ssize_t* lenp) +static Py_ssize_t SbkQByteArray_segcountproc(PyObject *self, Py_ssize_t *lenp) { if (lenp) *lenp = Py_TYPE(self)->tp_as_sequence->sq_length(self); return 1; } -static Py_ssize_t SbkQByteArray_readbufferproc(PyObject* self, Py_ssize_t segment, void** ptrptr) +static Py_ssize_t SbkQByteArray_readbufferproc(PyObject *self, Py_ssize_t segment, void **ptrptr) { if (segment || !Shiboken::Object::isValid(self)) return -1; - QByteArray* cppSelf = %CONVERTTOCPP[QByteArray*](self); - *ptrptr = reinterpret_cast(cppSelf->data()); + QByteArray * cppSelf = %CONVERTTOCPP[QByteArray *](self); + //XXX /|\ omitting this space crashes shiboken! + *ptrptr = reinterpret_cast(cppSelf->data()); return cppSelf->size(); } @@ -1191,7 +1192,7 @@ return !result ? -1 : 0; // @snippet qbytearray-setitem // @snippet qfiledevice-unmap -uchar *ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1)); +uchar *ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1)); %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ptr); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // @snippet qfiledevice-unmap @@ -1229,8 +1230,8 @@ if (socket != nullptr) { // @snippet qtranslator-load Py_ssize_t size; -uchar *ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1, &size)); -%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast(ptr), size); +uchar *ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1, &size)); +%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast(ptr), size); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // @snippet qtranslator-load @@ -1241,17 +1242,18 @@ Shiboken::AutoDecRef emptyTuple(PyTuple_New(0)); PyObject *pyTimer = reinterpret_cast(Shiboken::SbkType())->tp_new(Shiboken::SbkType(), emptyTuple, 0); reinterpret_cast(Shiboken::SbkType())->tp_init(pyTimer, emptyTuple, 0); -QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer); +QTimer * timer = %CONVERTTOCPP[QTimer *](pyTimer); +//XXX /|\ omitting this space crashes shiboken! Shiboken::AutoDecRef result( PyObject_CallMethod(pyTimer, - const_cast("connect"), - const_cast("OsOs"), + const_cast("connect"), + const_cast("OsOs"), pyTimer, SIGNAL(timeout()), %PYARG_2, %3) ); -Shiboken::Object::releaseOwnership((SbkObject*)pyTimer); +Shiboken::Object::releaseOwnership((SbkObject *)pyTimer); Py_XDECREF(pyTimer); timer->setSingleShot(true); timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater())); @@ -1263,16 +1265,16 @@ timer->start(%1); Shiboken::AutoDecRef emptyTuple(PyTuple_New(0)); PyObject *pyTimer = reinterpret_cast(Shiboken::SbkType())->tp_new(Shiboken::SbkType(), emptyTuple, 0); reinterpret_cast(Shiboken::SbkType())->tp_init(pyTimer, emptyTuple, 0); -QTimer* timer = %CONVERTTOCPP[QTimer*](pyTimer); +QTimer * timer = %CONVERTTOCPP[QTimer *](pyTimer); timer->setSingleShot(true); if (PyObject_TypeCheck(%2, PySideSignalInstanceTypeF())) { - PySideSignalInstance *signalInstance = reinterpret_cast(%2); + PySideSignalInstance *signalInstance = reinterpret_cast(%2); Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance))); Shiboken::AutoDecRef result( PyObject_CallMethod(pyTimer, - const_cast("connect"), - const_cast("OsOO"), + const_cast("connect"), + const_cast("OsOO"), pyTimer, SIGNAL(timeout()), PySide::Signal::getObject(signalInstance), @@ -1281,8 +1283,8 @@ if (PyObject_TypeCheck(%2, PySideSignalInstanceTypeF())) { } else { Shiboken::AutoDecRef result( PyObject_CallMethod(pyTimer, - const_cast("connect"), - const_cast("OsO"), + const_cast("connect"), + const_cast("OsO"), pyTimer, SIGNAL(timeout()), %PYARG_2) @@ -1290,7 +1292,7 @@ if (PyObject_TypeCheck(%2, PySideSignalInstanceTypeF())) { } timer->connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()), Qt::DirectConnection); -Shiboken::Object::releaseOwnership((SbkObject*)pyTimer); +Shiboken::Object::releaseOwnership(reinterpret_cast(pyTimer)); Py_XDECREF(pyTimer); timer->start(%1); // @snippet qtimer-singleshot-2 @@ -1322,7 +1324,7 @@ static void QCoreApplicationConstructor(PyObject *self, PyObject *pyargv, QCoreA PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0); if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) { *cptr = new QCoreApplicationWrapper(argc, argv); - Shiboken::Object::releaseOwnership(reinterpret_cast(self)); + Shiboken::Object::releaseOwnership(reinterpret_cast(self)); PySide::registerCleanupFunction(&PySide::destroyQCoreApplication); } } @@ -1342,10 +1344,10 @@ if (!PyTuple_SetItem(empty, 0, PyList_New(0))) { // @snippet qcoreapplication-instance PyObject *pyApp = Py_None; if (qApp) { - pyApp = reinterpret_cast( + pyApp = reinterpret_cast( Shiboken::BindingManager::instance().retrieveWrapper(qApp)); if (!pyApp) - pyApp = %CONVERTTOPYTHON[QCoreApplication*](qApp); + pyApp = %CONVERTTOPYTHON[QCoreApplication *](qApp); // this will keep app live after python exit (extra ref) } // PYSIDE-571: make sure that we return the singleton "None" @@ -1379,7 +1381,7 @@ Shiboken::Object::releaseOwnership(%PYARG_0); // @snippet qanimationgroup-clear for (int counter = 0, count = %CPPSELF.animationCount(); counter < count; ++counter ) { QAbstractAnimation *animation = %CPPSELF.animationAt(counter); - PyObject *obj = %CONVERTTOPYTHON[QAbstractAnimation*](animation); + PyObject *obj = %CONVERTTOPYTHON[QAbstractAnimation *](animation); Shiboken::Object::setParent(nullptr, obj); Py_DECREF(obj); } @@ -1403,11 +1405,12 @@ if (func) // @snippet qsignaltransition if (PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) { - PyObject *dataSource = PySide::Signal::getObject((PySideSignalInstance*)%PYARG_1); + PyObject *dataSource = PySide::Signal::getObject((PySideSignalInstance *)%PYARG_1); Shiboken::AutoDecRef obType(PyObject_Type(dataSource)); - QObject* sender = %CONVERTTOCPP[QObject*](dataSource); + QObject * sender = %CONVERTTOCPP[QObject *](dataSource); + //XXX /|\ omitting this space crashes shiboken! if (sender) { - const char*dataSignature = PySide::Signal::getSignature((PySideSignalInstance*)%PYARG_1); + const char *dataSignature = PySide::Signal::getSignature((PySideSignalInstance *)%PYARG_1); QByteArray signature(dataSignature); // Append SIGNAL flag (2) signature.prepend('2'); %0 = new QSignalTransitionWrapper(sender, signature, %2); @@ -1419,7 +1422,7 @@ if (PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) { QString signalName(%2); if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toLatin1().data(), QMetaMethod::Signal)) { QSignalTransition *%0 = %CPPSELF->addTransition(%1, %2, %3); - %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); + %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition *](%0); } else { Py_INCREF(Py_None); %PYARG_0 = Py_None; @@ -1433,16 +1436,17 @@ if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toLatin1().d // http://bugs.openbossa.org/show_bug.cgi?id=362 if (!PyObject_TypeCheck(%1, PySideSignalInstanceTypeF())) goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError; -PySideSignalInstance *signalInstance = reinterpret_cast(%1); -QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance)); +PySideSignalInstance *signalInstance = reinterpret_cast(%1); +QObject * sender = %CONVERTTOCPP[QObject *](PySide::Signal::getObject(signalInstance)); +//XXX /|\ omitting this space crashes shiboken! QSignalTransition *%0 = %CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance),%2); -%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); +%PYARG_0 = %CONVERTTOPYTHON[QSignalTransition *](%0); // @snippet qstate-addtransition-2 // @snippet qstatemachine-configuration %PYARG_0 = PySet_New(0); for (auto *abs_state : %CPPSELF.configuration()) { - Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractState*](abs_state)); + Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractState *](abs_state)); Shiboken::Object::setParent(self, obj); PySet_Add(%PYARG_0, obj); } @@ -1451,7 +1455,7 @@ for (auto *abs_state : %CPPSELF.configuration()) { // @snippet qstatemachine-defaultanimations %PYARG_0 = PyList_New(0); for (auto *abs_anim : %CPPSELF.defaultAnimations()) { - Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractAnimation*](abs_anim)); + Shiboken::AutoDecRef obj(%CONVERTTOPYTHON[QAbstractAnimation *](abs_anim)); Shiboken::Object::setParent(self, obj); PyList_Append(%PYARG_0, obj); } @@ -1482,16 +1486,16 @@ QT_END_NAMESPACE // @snippet qt-registerresourcedata // @snippet qt-qregisterresourcedata -%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast(PyBytes_AS_STRING(%PYARG_2)), - reinterpret_cast(PyBytes_AS_STRING(%PYARG_3)), - reinterpret_cast(PyBytes_AS_STRING(%PYARG_4))); +%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast(PyBytes_AS_STRING(%PYARG_2)), + reinterpret_cast(PyBytes_AS_STRING(%PYARG_3)), + reinterpret_cast(PyBytes_AS_STRING(%PYARG_4))); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // @snippet qt-qregisterresourcedata // @snippet qt-qunregisterresourcedata -%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast(PyBytes_AS_STRING(%PYARG_2)), - reinterpret_cast(PyBytes_AS_STRING(%PYARG_3)), - reinterpret_cast(PyBytes_AS_STRING(%PYARG_4))); +%RETURN_TYPE %0 = %FUNCTION_NAME(%1, reinterpret_cast(PyBytes_AS_STRING(%PYARG_2)), + reinterpret_cast(PyBytes_AS_STRING(%PYARG_3)), + reinterpret_cast(PyBytes_AS_STRING(%PYARG_4))); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // @snippet qt-qunregisterresourcedata @@ -1502,8 +1506,8 @@ QT_END_NAMESPACE // @snippet use-stream-for-format-security // @snippet qresource-registerResource - auto ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1)); - %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast(ptr), %2); + auto ptr = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_1)); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast(ptr), %2); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // @snippet qresource-registerResource @@ -1529,11 +1533,11 @@ QString &res = *%0; // @snippet return-readData %RETURN_TYPE %0 = 0; if (PyBytes_Check(%PYARG_0)) { - %0 = PyBytes_GET_SIZE((PyObject*)%PYARG_0); - memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %0); + %0 = PyBytes_GET_SIZE((PyObject *)%PYARG_0); + memcpy(%1, PyBytes_AS_STRING((PyObject *)%PYARG_0), %0); } else if (Shiboken::String::check(%PYARG_0)) { - %0 = Shiboken::String::len((PyObject*)%PYARG_0); - memcpy(%1, Shiboken::String::toCString((PyObject*)%PYARG_0), %0); + %0 = Shiboken::String::len((PyObject *)%PYARG_0); + memcpy(%1, Shiboken::String::toCString((PyObject *)%PYARG_0), %0); } // @snippet return-readData @@ -1545,7 +1549,7 @@ QByteArray ba(1 + int(%2), char(0)); // @snippet qt-module-shutdown { // Avoid name clash - Shiboken::AutoDecRef regFunc((PyObject*)NULL); + Shiboken::AutoDecRef regFunc(static_cast(nullptr)); Shiboken::AutoDecRef atexit(Shiboken::Module::import("atexit")); if (atexit.isNull()) { qWarning("Module atexit not found for registering __moduleShutdown"); @@ -1586,12 +1590,12 @@ QByteArray ba(1 + int(%2), char(0)); // @snippet conversion-pyunicode #ifndef Py_LIMITED_API -Py_UNICODE* unicode = PyUnicode_AS_UNICODE(%in); +Py_UNICODE *unicode = PyUnicode_AS_UNICODE(%in); # if defined(Py_UNICODE_WIDE) // cast as Py_UNICODE can be a different type -%out = QString::fromUcs4((const uint*)unicode); +%out = QString::fromUcs4((const uint *)unicode); # else -%out = QString::fromUtf16((const ushort*)unicode, PyUnicode_GET_SIZE(%in)); +%out = QString::fromUtf16((const ushort *)unicode, PyUnicode_GET_SIZE(%in)); # endif #else wchar_t *temp = PyUnicode_AsWideCharString(%in, NULL); @@ -1602,7 +1606,8 @@ PyMem_Free(temp); // @snippet conversion-pystring #ifndef IS_PY3K -const char* str = %CONVERTTOCPP[const char*](%in); +const char * str = %CONVERTTOCPP[const char *](%in); +//XXX /|\ omitting this space crashes shiboken! %out = %OUTTYPE(str); #endif // @snippet conversion-pystring @@ -1650,7 +1655,7 @@ if (!typeCode || !typeName) { %out = QVariant::fromValue(PySide::PyObjectWrapper(%in)); } else { - QVariant var(typeCode, (void*)0); + QVariant var(typeCode, nullptr); Shiboken::Conversions::SpecificConverter converter(typeName); converter.toCpp(pyIn, var.data()); %out = var; @@ -1680,12 +1685,12 @@ QVariant ret = QVariant_convertToVariantList(%in); const char *typeName; if (Shiboken::String::checkType(reinterpret_cast(%in))) typeName = "QString"; -else if (%in == reinterpret_cast(&PyFloat_Type)) +else if (%in == reinterpret_cast(&PyFloat_Type)) typeName = "double"; // float is a UserType in QVariant. -else if (%in == reinterpret_cast(&PyLong_Type)) +else if (%in == reinterpret_cast(&PyLong_Type)) typeName = "int"; // long is a UserType in QVariant. else if (Py_TYPE(%in) == SbkObjectType_TypeF()) - typeName = Shiboken::ObjectType::getOriginalName((SbkObjectType*)%in); + typeName = Shiboken::ObjectType::getOriginalName((SbkObjectType *)%in); else typeName = reinterpret_cast(%in)->tp_name; %out = QVariant::nameToType(typeName); @@ -1825,7 +1830,7 @@ PyObject *%out; PyTypeObject *pyType = nullptr; if (typeName) pyType = Shiboken::Conversions::getPythonTypeObject(typeName); -%out = pyType ? (reinterpret_cast(pyType)) : Py_None; +%out = pyType ? (reinterpret_cast(pyType)) : Py_None; Py_INCREF(%out); return %out; // @snippet return-qvariant-type diff --git a/sources/pyside2/PySide2/glue/qtgui.cpp b/sources/pyside2/PySide2/glue/qtgui.cpp index aef9e4b59..5be8cc287 100644 --- a/sources/pyside2/PySide2/glue/qtgui.cpp +++ b/sources/pyside2/PySide2/glue/qtgui.cpp @@ -72,7 +72,7 @@ if (QTransform::squareToQuad(%1, _result)) { // @snippet qtransform-squaretoquad // @snippet qbitmap-fromdata -uchar *buffer = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_2)); +uchar *buffer = reinterpret_cast(Shiboken::Buffer::getPointer(%PYARG_2)); QBitmap %0 = QBitmap::fromData(%1, buffer, %3); %PYARG_0 = %CONVERTTOPYTHON[QBitmap](%0); // @snippet qbitmap-fromdata @@ -102,7 +102,7 @@ return %CONVERTTOPYTHON[int](item); // @snippet qtextblock-setuserdata const QTextDocument *doc = %CPPSELF.document(); if (doc) { - Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); + Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument *](doc)); Shiboken::Object::setParent(pyDocument, %PYARG_1); } // @snippet qtextblock-setuserdata @@ -110,7 +110,7 @@ if (doc) { // @snippet qtextblock-userdata const QTextDocument *doc = %CPPSELF.document(); if (doc) { - Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument*](doc)); + Shiboken::AutoDecRef pyDocument(%CONVERTTOPYTHON[QTextDocument *](doc)); Shiboken::Object::setParent(pyDocument, %PYARG_0); } // @snippet qtextblock-userdata @@ -138,7 +138,7 @@ for (int i = 0, i_max = %CPPSELF.count(); i < i_max; ++i){ // @snippet qpolygon-operatorlowerlower // %FUNCTION_NAME() *%CPPSELF << %1; -%PYARG_0 = %CONVERTTOPYTHON[QPolygon*](%CPPSELF); +%PYARG_0 = %CONVERTTOPYTHON[QPolygon *](%CPPSELF); // @snippet qpolygon-operatorlowerlower // @snippet qpixmap @@ -372,7 +372,7 @@ if (%CPPSELF.%FUNCTION_NAME(%1, &p)) { // Clear parent from the old child QStandardItem *_i = %CPPSELF->child(%1, %2); if (_i) { - PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem *](_i); Shiboken::Object::setParent(nullptr, _pyI); } // @snippet qstandarditem-setchild-1 @@ -381,7 +381,7 @@ if (_i) { // Clear parent from the old child QStandardItem *_i = %CPPSELF->child(%1); if (_i) { - PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem *](_i); Shiboken::Object::setParent(nullptr, _pyI); } // @snippet qstandarditem-setchild-2 @@ -395,7 +395,7 @@ bool ret = !(&%CPPSELF == %1); // Clear parent from the old child QStandardItem *_i = %CPPSELF->item(%1, %2); if (_i) { - PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem *](_i); Shiboken::Object::setParent(nullptr, _pyI); } // @snippet qstandarditemmodel-setitem-1 @@ -404,7 +404,7 @@ if (_i) { // Clear parent from the old child QStandardItem *_i = %CPPSELF->item(%1); if (_i) { - PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem *](_i); Shiboken::Object::setParent(nullptr, _pyI); } // @snippet qstandarditemmodel-setitem-2 @@ -413,7 +413,7 @@ if (_i) { // Clear parent from the old child QStandardItem *_i = %CPPSELF->verticalHeaderItem(%1); if (_i) { - PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem*](_i); + PyObject *_pyI = %CONVERTTOPYTHON[QStandardItem *](_i); Shiboken::Object::setParent(nullptr, _pyI); } // @snippet qstandarditemmodel-setverticalheaderitem @@ -503,7 +503,7 @@ static void QGuiApplicationConstructor(PyObject *self, PyObject *pyargv, QGuiApp PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0); if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) { *cptr = new QGuiApplicationWrapper(argc, argv, 0); - Shiboken::Object::releaseOwnership(reinterpret_cast(self)); + Shiboken::Object::releaseOwnership(reinterpret_cast(self)); PySide::registerCleanupFunction(&PySide::destroyQCoreApplication); } } diff --git a/sources/pyside2/PySide2/glue/qtmultimedia.cpp b/sources/pyside2/PySide2/glue/qtmultimedia.cpp index 520b5c4fa..5a3f3a5e7 100644 --- a/sources/pyside2/PySide2/glue/qtmultimedia.cpp +++ b/sources/pyside2/PySide2/glue/qtmultimedia.cpp @@ -39,7 +39,8 @@ // @snippet upcast %BEGIN_ALLOW_THREADS -QObject* upcastedArg = %CONVERTTOCPP[QObject*](%PYARG_1); +QObject * upcastedArg = %CONVERTTOCPP[QObject *](%PYARG_1); +//XXX /|\ omitting this space crashes shiboken! %CPPSELF.%FUNCTION_NAME(reinterpret_cast< %ARG1_TYPE >(upcastedArg)); %END_ALLOW_THREADS // @snippet upcast diff --git a/sources/pyside2/PySide2/glue/qtopengl.cpp b/sources/pyside2/PySide2/glue/qtopengl.cpp index 6c106522c..25b6ee096 100644 --- a/sources/pyside2/PySide2/glue/qtopengl.cpp +++ b/sources/pyside2/PySide2/glue/qtopengl.cpp @@ -39,7 +39,7 @@ // @snippet qglbuffer-allocate int size = (%2 < 0) ? %1.size() : %2; -%CPPSELF.allocate((const void*) %1.data(), size); +%CPPSELF.allocate(static_cast(%1.data()), size); // @snippet qglbuffer-allocate // @snippet qglbuffer-read @@ -47,7 +47,7 @@ char *data = new char[%3]; bool result = %CPPSELF.read(%1, data, %3); QByteArray ret; if (result) - ret.append((const char*)data, %3); + ret.append(data, %3); %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](result)); PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QByteArray](ret)); @@ -56,12 +56,12 @@ delete[] data; // @snippet qglbuffer-write int size = (%3 < 0) ? %2.size() : %3; -%CPPSELF.write(%1, (const void*) %2.data(), size); +%CPPSELF.write(%1, static_cast(%2.data()), size); // @snippet qglbuffer-write // @snippet qglbuffer-map Py_ssize_t dataSize = %CPPSELF.size(); -void* data = %CPPSELF.map(%1); +void *data = %CPPSELF.map(%1); if (!data) { Py_INCREF(Py_None); diff --git a/sources/pyside2/PySide2/glue/qtscript.cpp b/sources/pyside2/PySide2/glue/qtscript.cpp index 7efc26f3e..cf168d6bd 100644 --- a/sources/pyside2/PySide2/glue/qtscript.cpp +++ b/sources/pyside2/PySide2/glue/qtscript.cpp @@ -54,7 +54,7 @@ QVariant res = %CPPSELF.property(Shiboken::String::toCString(key.object())).toVa if (res.isValid()) { return %CONVERTTOPYTHON[QVariant](res); } else { - PyObject* errorType = PyInt_Check(_key) ? PyExc_IndexError : PyExc_KeyError; + PyObject *errorType = PyInt_Check(_key) ? PyExc_IndexError : PyExc_KeyError; PyErr_SetString(errorType, "Key not found."); return 0; } diff --git a/sources/pyside2/PySide2/glue/qtuitools.cpp b/sources/pyside2/PySide2/glue/qtuitools.cpp index d0469e97d..552a9009c 100644 --- a/sources/pyside2/PySide2/glue/qtuitools.cpp +++ b/sources/pyside2/PySide2/glue/qtuitools.cpp @@ -48,14 +48,14 @@ #include #include -static void createChildrenNameAttributes(PyObject* root, QObject* object) +static void createChildrenNameAttributes(PyObject *root, QObject *object) { for (auto *child : object->children()) { const QByteArray name = child->objectName().toLocal8Bit(); if (!name.isEmpty() && !name.startsWith("_") && !name.startsWith("qt_")) { if (!PyObject_HasAttrString(root, name.constData())) { - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject*](child)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject *](child)); PyObject_SetAttrString(root, name.constData(), pyChild); } createChildrenNameAttributes(root, child); @@ -64,15 +64,15 @@ static void createChildrenNameAttributes(PyObject* root, QObject* object) } } -static PyObject* QUiLoadedLoadUiFromDevice(QUiLoader* self, QIODevice* dev, QWidget* parent) +static PyObject *QUiLoadedLoadUiFromDevice(QUiLoader *self, QIODevice *dev, QWidget *parent) { - QWidget* wdg = self->load(dev, parent); + QWidget *wdg = self->load(dev, parent); if (wdg) { - PyObject* pyWdg = %CONVERTTOPYTHON[QWidget*](wdg); + PyObject *pyWdg = %CONVERTTOPYTHON[QWidget *](wdg); createChildrenNameAttributes(pyWdg, wdg); if (parent) { - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](parent)); Shiboken::Object::setParent(pyParent, pyWdg); } return pyWdg; @@ -83,7 +83,7 @@ static PyObject* QUiLoadedLoadUiFromDevice(QUiLoader* self, QIODevice* dev, QWid return nullptr; } -static PyObject* QUiLoaderLoadUiFromFileName(QUiLoader* self, const QString& uiFile, QWidget* parent) +static PyObject *QUiLoaderLoadUiFromFileName(QUiLoader *self, const QString &uiFile, QWidget *parent) { QFile fd(uiFile); return QUiLoadedLoadUiFromDevice(self, &fd, parent); diff --git a/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp b/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp index 086ee3b85..c0f182747 100644 --- a/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp +++ b/sources/pyside2/PySide2/glue/qtwebkitwidgets.cpp @@ -38,7 +38,7 @@ ****************************************************************************/ // @snippet qwebview-page -SbkObject* _pyReturn = reinterpret_cast(%PYARG_0); +auto _pyReturn = reinterpret_cast(%PYARG_0); if (!Shiboken::Object::hasParentInfo(_pyReturn)) Shiboken::Object::setParent(%PYSELF, %PYARG_0); // @snippet qwebview-page @@ -67,7 +67,7 @@ if (_signalIndex == -1) { if (_signalIndex == id) { Shiboken::GilState gil; - PyObject* self = (PyObject*)Shiboken::BindingManager::instance().retrieveWrapper(this); + auto self = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(this)); if (self) { Shiboken::AutoDecRef _pyMethod(PyObject_GetAttrString(self, "shouldInterruptJavaScript")); diff --git a/sources/pyside2/PySide2/glue/qtwidgets.cpp b/sources/pyside2/PySide2/glue/qtwidgets.cpp index b44be183d..0e0b025a6 100644 --- a/sources/pyside2/PySide2/glue/qtwidgets.cpp +++ b/sources/pyside2/PySide2/glue/qtwidgets.cpp @@ -44,13 +44,13 @@ // @snippet qtreewidgetitemiterator-next if (**%CPPSELF) { QTreeWidgetItemIterator *%0 = new QTreeWidgetItemIterator((*%CPPSELF)++); - %PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItemIterator*](%0); + %PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItemIterator *](%0); } // @snippet qtreewidgetitemiterator-next // @snippet qtreewidgetitemiterator-value -QTreeWidgetItem *%0 = %CPPSELF.operator*(); -%PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItem*](%0); +QTreeWidgetItem *%0 = %CPPSELF.operator *(); +%PYARG_0 = %CONVERTTOPYTHON[QTreeWidgetItem *](%0); Shiboken::Object::releaseOwnership(%PYARG_0); // @snippet qtreewidgetitemiterator-value @@ -62,7 +62,7 @@ PyDict_SetItemString(reinterpret_cast(Sbk_QGraphicsItem_TypeF()) // @snippet qgraphicsitem-scene-return-parenting if (%0) { QObject *parent = %0->parent(); - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QObject*](parent)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QObject *](parent)); Shiboken::Object::setParent(pyParent, %PYARG_0); } // @snippet qgraphicsitem-scene-return-parenting @@ -72,7 +72,7 @@ QGraphicsItem *item_ = NULL; %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_); %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); -PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem*](item_)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem *](item_)); // @snippet qgraphicsitem-isblockedbymodalpanel // @snippet qitemeditorfactory-registereditor @@ -81,7 +81,7 @@ Shiboken::Object::releaseOwnership(%PYARG_2); // @snippet qitemeditorfactory-setdefaultfactory //this function is static we need keep ref to default value, to be able to call python virtual functions -static PyObject* _defaultValue = 0; +static PyObject *_defaultValue = nullptr; %CPPSELF.%FUNCTION_NAME(%1); Py_INCREF(%PYARG_1); if (_defaultValue) @@ -111,9 +111,9 @@ PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG5_TYPE](%5)); // @snippet qfiledialog-return // @snippet qmenu-glue -inline PyObject* addActionWithPyObject(QMenu* self, const QIcon& icon, const QString& text, PyObject* callback, const QKeySequence& shortcut) +inline PyObject *addActionWithPyObject(QMenu *self, const QIcon &icon, const QString &text, PyObject *callback, const QKeySequence &shortcut) { - QAction* act = self->addAction(text); + QAction *act = self->addAction(text); if (!icon.isNull()) act->setIcon(icon); @@ -123,7 +123,7 @@ inline PyObject* addActionWithPyObject(QMenu* self, const QIcon& icon, const QSt self->addAction(act); - PyObject* pyAct = %CONVERTTOPYTHON[QAction*](act); + PyObject *pyAct = %CONVERTTOPYTHON[QAction *](act); Shiboken::AutoDecRef result(PyObject_CallMethod(pyAct, const_cast("connect"), const_cast("OsO"), @@ -151,7 +151,7 @@ inline PyObject* addActionWithPyObject(QMenu* self, const QIcon& icon, const QSt // @snippet qmenu-addaction-3 // @snippet qmenu-clear -Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); const auto &actions = %CPPSELF.actions(); for (auto *act : actions) { if (auto wrapper = bm.retrieveWrapper(act)) { @@ -165,15 +165,15 @@ for (auto *act : actions) { // @snippet qmenu-clear // @snippet qmenubar-glue -inline PyObject* -addActionWithPyObject(QMenuBar* self, const QString& text, PyObject* callback) +inline PyObject * +addActionWithPyObject(QMenuBar *self, const QString &text, PyObject *callback) { - QAction* act = self->addAction(text); + QAction *act = self->addAction(text); self->addAction(act); - PyObject* pyAct = %CONVERTTOPYTHON[QAction*](act); - PyObject* result = PyObject_CallMethod(pyAct, + PyObject *pyAct = %CONVERTTOPYTHON[QAction *](act); + PyObject *result = PyObject_CallMethod(pyAct, const_cast("connect"), const_cast("OsO"), pyAct, @@ -193,7 +193,7 @@ addActionWithPyObject(QMenuBar* self, const QString& text, PyObject* callback) // @snippet qmenubar-clear const auto &actions = %CPPSELF.actions(); for (auto *act : actions) { - Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction *](act)); Shiboken::Object::setParent(NULL, pyAct); Shiboken::Object::invalidate(pyAct); } @@ -224,28 +224,28 @@ if (!result.isNull()) // @snippet qtoolbox-removeitem QWidget *_widget = %CPPSELF.widget(%1); if (_widget) { - Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](_widget)); + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget *](_widget)); Shiboken::Object::setParent(0, pyWidget); } // @snippet qtoolbox-removeitem // @snippet qlayout-help-functions -void addLayoutOwnership(QLayout* layout, QLayoutItem* item); -void removeLayoutOwnership(QLayout* layout, QWidget* widget); +void addLayoutOwnership(QLayout *layout, QLayoutItem *item); +void removeLayoutOwnership(QLayout *layout, QWidget *widget); -inline QByteArray retrieveObjectName(PyObject* obj) +inline QByteArray retrieveObjectName(PyObject *obj) { Shiboken::AutoDecRef objName(PyObject_Str(obj)); return Shiboken::String::toCString(objName); } -inline void addLayoutOwnership(QLayout* layout, QWidget* widget) +inline void addLayoutOwnership(QLayout *layout, QWidget *widget) { //transfer ownership to parent widget QWidget *lw = layout->parentWidget(); QWidget *pw = widget->parentWidget(); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget *](widget)); //Transfer parent to layout widget if (pw && lw && pw != lw) @@ -253,99 +253,98 @@ inline void addLayoutOwnership(QLayout* layout, QWidget* widget) if (!lw && !pw) { //keep the reference while the layout is orphan - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](layout)); - Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](layout)); + Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); } else { if (!lw) lw = pw; - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](lw)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](lw)); Shiboken::Object::setParent(pyParent, pyChild); } } -inline void addLayoutOwnership(QLayout* layout, QLayout* other) +inline void addLayoutOwnership(QLayout *layout, QLayout *other) { //transfer all children widgets from other to layout parent widget - QWidget* parent = layout->parentWidget(); + QWidget *parent = layout->parentWidget(); if (!parent) { //keep the reference while the layout is orphan - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](other)); - Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout *](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout *](other)); + Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), + retrieveObjectName(pyParent).data(), pyChild, true); return; } for (int i=0, i_max=other->count(); i < i_max; i++) { - QLayoutItem* item = other->itemAt(i); + QLayoutItem *item = other->itemAt(i); if (PyErr_Occurred() || !item) return; addLayoutOwnership(layout, item); } - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](other)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout *](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout *](other)); Shiboken::Object::setParent(pyParent, pyChild); } -inline void addLayoutOwnership(QLayout* layout, QLayoutItem* item) +inline void addLayoutOwnership(QLayout *layout, QLayoutItem *item) { if (!item) return; - QWidget* w = item->widget(); - if (w) + if (QWidget *w = item->widget()) { addLayoutOwnership(layout, w); - else { - QLayout* l = item->layout(); - if (l) + } else { + if (QLayout *l = item->layout()) addLayoutOwnership(layout, l); } - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem*](item)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout *](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem *](item)); Shiboken::Object::setParent(pyParent, pyChild); } -static void removeWidgetFromLayout(QLayout* layout, QWidget* widget) +static void removeWidgetFromLayout(QLayout *layout, QWidget *widget) { - QWidget* parent = widget->parentWidget(); + QWidget *parent = widget->parentWidget(); if (!parent) { //remove reference on layout - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](layout)); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); - Shiboken::Object::removeReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget *](widget)); + Shiboken::Object::removeReference(reinterpret_cast(pyParent.object()), + retrieveObjectName(pyParent).data(), pyChild); } else { //give the ownership to parent - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](parent)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget *](widget)); Shiboken::Object::setParent(pyParent, pyChild); } } -inline void removeLayoutOwnership(QLayout* layout, QLayoutItem* item) +inline void removeLayoutOwnership(QLayout *layout, QLayoutItem *item) { - QWidget* w = item->widget(); - if (w) + if (QWidget *w = item->widget()) { removeWidgetFromLayout(layout, w); - else { - QLayout* l = item->layout(); + } else { + QLayout *l = item->layout(); if (l && item != l) removeLayoutOwnership(layout, l); } - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem*](item)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem *](item)); Shiboken::Object::invalidate(pyChild); Shiboken::Object::setParent(0, pyChild); } -inline void removeLayoutOwnership(QLayout* layout, QWidget* widget) +inline void removeLayoutOwnership(QLayout *layout, QWidget *widget) { if (!widget) return; for (int i=0, i_max=layout->count(); i < i_max; i++) { - QLayoutItem* item = layout->itemAt(i); + QLayoutItem *item = layout->itemAt(i); if (PyErr_Occurred() || !item) return; if (item->widget() == widget) @@ -385,11 +384,11 @@ PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](d)); // @snippet qgridlayout-getitemposition // @snippet qgraphicsscene-destroyitemgroup -QGraphicsItem* parentItem = %1->parentItem(); -Shiboken::AutoDecRef parent(%CONVERTTOPYTHON[QGraphicsItem*](parentItem)); +QGraphicsItem *parentItem = %1->parentItem(); +Shiboken::AutoDecRef parent(%CONVERTTOPYTHON[QGraphicsItem *](parentItem)); const auto &childItems = %1->childItems(); for (auto *item : childItems) - Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[QGraphicsItem*](item)); + Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[QGraphicsItem *](item)); %BEGIN_ALLOW_THREADS %CPPSELF.%FUNCTION_NAME(%1); %END_ALLOW_THREADS @@ -400,16 +399,16 @@ Shiboken::Object::invalidate(%PYARG_1); // @snippet qgraphicsscene-addwidget %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); -Shiboken::Object::keepReference((SbkObject*)%PYARG_0, "setWidget(QWidget*)1", %PYARG_1); +Shiboken::Object::keepReference(reinterpret_cast(%PYARG_0), "setWidget(QWidget*)1", %PYARG_1); // @snippet qgraphicsscene-addwidget // @snippet qgraphicsscene-clear -const QList items = %CPPSELF.items(); -Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +const QList items = %CPPSELF.items(); +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); for (auto *item : items) { - SbkObject* obj = bm.retrieveWrapper(item); + SbkObject *obj = bm.retrieveWrapper(item); if (obj) { - if (reinterpret_cast(obj)->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway. + if (reinterpret_cast(obj)->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway. Shiboken::Object::invalidate(obj); Shiboken::Object::removeParent(obj); } @@ -422,9 +421,8 @@ QTreeWidgetItem *rootItem = %CPPSELF.invisibleRootItem(); Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); for (int i = 0, i_count = rootItem->childCount(); i < i_count; ++i) { QTreeWidgetItem *item = rootItem->child(i); - SbkObject* wrapper = bm.retrieveWrapper(item); - if (wrapper) - Shiboken::Object::setParent(0, reinterpret_cast(wrapper)); + if (SbkObject *wrapper = bm.retrieveWrapper(item)) + Shiboken::Object::setParent(nullptr, reinterpret_cast(wrapper)); } // @snippet qtreewidget-clear @@ -440,7 +438,7 @@ Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); for (int i = 0, count = %CPPSELF.count(); i < count; ++i) { QListWidgetItem *item = %CPPSELF.item(i); if (auto wrapper = bm.retrieveWrapper(item)) { - auto pyObj = reinterpret_cast(wrapper); + auto pyObj = reinterpret_cast(wrapper); Py_INCREF(pyObj); Shiboken::Object::setParent(NULL, pyObj); Shiboken::Object::invalidate(pyObj); @@ -461,31 +459,30 @@ static QString retrieveObjectName(PyObject *obj) // Transfer objects ownership from layout to widget static inline void qwidgetReparentLayout(QWidget *parent, QLayout *layout) { - Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget *](parent)); for (int i=0, i_count = layout->count(); i < i_count; i++) { - QLayoutItem* item = layout->itemAt(i); + QLayoutItem *item = layout->itemAt(i); if (PyErr_Occurred() || !item) return; - QWidget* w = item->widget(); - if (w) { - QWidget* pw = w->parentWidget(); + if (QWidget *w = item->widget()) { + QWidget *pw = w->parentWidget(); if (pw != parent) { - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](w)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget *](w)); Shiboken::Object::setParent(pyParent, pyChild); } } else { - QLayout* l = item->layout(); - if (l) + if (QLayout *l = item->layout()) qwidgetReparentLayout(parent, l); } } - Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout *](layout)); Shiboken::Object::setParent(pyParent, pyChild); //remove previous references - Shiboken::Object::keepReference(reinterpret_cast(pyChild.object()), qPrintable(retrieveObjectName(pyChild)), Py_None); + Shiboken::Object::keepReference(reinterpret_cast(pyChild.object()), + qPrintable(retrieveObjectName(pyChild)), Py_None); } static inline void qwidgetSetLayout(QWidget *self, QLayout *layout) @@ -493,11 +490,11 @@ static inline void qwidgetSetLayout(QWidget *self, QLayout *layout) if (!layout || self->layout()) return; - QObject* oldParent = layout->parent(); + QObject *oldParent = layout->parent(); if (oldParent && oldParent != self) { if (oldParent->isWidgetType()) { // remove old parent policy - Shiboken::AutoDecRef pyLayout(%CONVERTTOPYTHON[QLayout*](layout)); + Shiboken::AutoDecRef pyLayout(%CONVERTTOPYTHON[QLayout *](layout)); Shiboken::Object::setParent(Py_None, pyLayout); } else { PyErr_Format(PyExc_RuntimeError, "QWidget::setLayout: Attempting to set QLayout \"%s\" on %s \"%s\", when the QLayout already has a parent", @@ -517,20 +514,20 @@ static inline void qwidgetSetLayout(QWidget *self, QLayout *layout) // @snippet qwidget-glue // @snippet qwidget-setstyle -Shiboken::Object::keepReference(reinterpret_cast(%PYSELF), "__style__", %PYARG_1); +Shiboken::Object::keepReference(reinterpret_cast(%PYSELF), "__style__", %PYARG_1); // @snippet qwidget-setstyle // @snippet qwidget-style -QStyle* myStyle = %CPPSELF->style(); +QStyle *myStyle = %CPPSELF->style(); if (myStyle && qApp) { -%PYARG_0 = %CONVERTTOPYTHON[QStyle*](myStyle); +%PYARG_0 = %CONVERTTOPYTHON[QStyle *](myStyle); QStyle *appStyle = qApp->style(); if (appStyle == myStyle) { - Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication*](qApp)); + Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication *](qApp)); Shiboken::Object::setParent(pyApp, %PYARG_0); Shiboken::Object::releaseOwnership(%PYARG_0); } else { - Shiboken::Object::keepReference(reinterpret_cast(%PYSELF), "__style__", %PYARG_0); + Shiboken::Object::keepReference(reinterpret_cast(%PYSELF), "__style__", %PYARG_0); } } // @snippet qwidget-style @@ -543,7 +540,7 @@ static void QApplicationConstructor(PyObject *self, PyObject *pyargv, QApplicati PyObject *stringlist = PyTuple_GET_ITEM(pyargv, 0); if (Shiboken::listToArgcArgv(stringlist, &argc, &argv, "PySideApp")) { *cptr = new QApplicationWrapper(argc, argv, 0); - Shiboken::Object::releaseOwnership(reinterpret_cast(self)); + Shiboken::Object::releaseOwnership(reinterpret_cast(self)); PySide::registerCleanupFunction(&PySide::destroyQCoreApplication); } } @@ -551,7 +548,7 @@ static void QApplicationConstructor(PyObject *self, PyObject *pyargv, QApplicati // @snippet qapplication-setStyle if (qApp) { - Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication*](qApp)); + Shiboken::AutoDecRef pyApp(%CONVERTTOPYTHON[QApplication *](qApp)); Shiboken::Object::setParent(pyApp, %PYARG_1); Shiboken::Object::releaseOwnership(%PYARG_1); } @@ -563,19 +560,19 @@ qwidgetSetLayout(%CPPSELF, %1); // @snippet qwidget-setlayout // @snippet qtabwidget-removetab -QWidget* tab = %CPPSELF.widget(%1); +QWidget *tab = %CPPSELF.widget(%1); if (tab) { - Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](tab)); + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget *](tab)); %CPPSELF.%FUNCTION_NAME(%1); } // @snippet qtabwidget-removetab // @snippet qtabwidget-clear -Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); for (int i = 0, count = %CPPSELF.count(); i < count; ++i) { - QWidget* widget = %CPPSELF.widget(i); + QWidget *widget = %CPPSELF.widget(i); if (bm.hasWrapper(widget)) { - Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget *](widget)); Shiboken::Object::releaseOwnership(pyWidget); } } @@ -588,7 +585,7 @@ for (int i = 0, count = %CPPSELF.count(); i < count; ++i) { // @snippet qtoolbar-addaction-1 QAction *action = %CPPSELF.addAction(%1, %2); -%PYARG_0 = %CONVERTTOPYTHON[QAction*](action); +%PYARG_0 = %CONVERTTOPYTHON[QAction *](action); Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, const_cast("connect"), const_cast("OsO"), @@ -598,7 +595,7 @@ Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, // @snippet qtoolbar-addaction-2 QAction *action = %CPPSELF.addAction(%1); -%PYARG_0 = %CONVERTTOPYTHON[QAction*](action); +%PYARG_0 = %CONVERTTOPYTHON[QAction *](action); Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, const_cast("connect"), const_cast("OsO"), @@ -611,12 +608,12 @@ Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, // @snippet qtoolbar-addaction-3 // @snippet qtoolbar-clear -QList lst; -Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); -const auto &toolButtonChildren = %CPPSELF.findChildren(); +QList lst; +Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); +const auto &toolButtonChildren = %CPPSELF.findChildren(); for (auto *child : toolButtonChildren) { if (bm.hasWrapper(child)) { - PyObject* pyChild = %CONVERTTOPYTHON[QToolButton*](child); + PyObject *pyChild = %CONVERTTOPYTHON[QToolButton *](child); Shiboken::Object::setParent(0, pyChild); lst << pyChild; } @@ -625,14 +622,14 @@ for (auto *child : toolButtonChildren) { //Remove actions const auto &actions = %CPPSELF.actions(); for (auto *act : actions) { - Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction *](act)); Shiboken::Object::setParent(NULL, pyAct); Shiboken::Object::invalidate(pyAct); } %CPPSELF.clear(); for (auto *obj : lst) { - Shiboken::Object::invalidate(reinterpret_cast(obj)); + Shiboken::Object::invalidate(reinterpret_cast(obj)); Py_XDECREF(obj); } // @snippet qtoolbar-clear @@ -648,9 +645,9 @@ if (!PyTuple_SetItem(empty, 0, PyList_New(0))) // @snippet qapplication-2 // @snippet qgraphicsproxywidget-setwidget -QWidget* _old = %CPPSELF.widget(); +QWidget *_old = %CPPSELF.widget(); if (_old) - Shiboken::Object::setParent(nullptr, %CONVERTTOPYTHON[QWidget*](_old)); + Shiboken::Object::setParent(nullptr, %CONVERTTOPYTHON[QWidget *](_old)); %CPPSELF.%FUNCTION_NAME(%1); Shiboken::Object::setParent(%PYSELF, %PYARG_1); // @snippet qgraphicsproxywidget-setwidget diff --git a/sources/pyside2/PySide2/glue/qtxml.cpp b/sources/pyside2/PySide2/glue/qtxml.cpp index ff8be58e2..684ff33c4 100644 --- a/sources/pyside2/PySide2/glue/qtxml.cpp +++ b/sources/pyside2/PySide2/glue/qtxml.cpp @@ -38,13 +38,13 @@ ****************************************************************************/ // @snippet qxmlentityresolver-resolveentity -QXmlInputSource* _qxmlinputsource_arg_ = nullptr; +QXmlInputSource *_qxmlinputsource_arg_ = nullptr; %BEGIN_ALLOW_THREADS %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); %END_ALLOW_THREADS %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); -PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QXmlInputSource*](_qxmlinputsource_arg_)); +PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QXmlInputSource *](_qxmlinputsource_arg_)); // @snippet qxmlentityresolver-resolveentity // @snippet qdomdocument-setcontent diff --git a/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp b/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp index b559ad1d4..75ad3b265 100644 --- a/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp +++ b/sources/pyside2/PySide2/glue/qtxmlpatterns.cpp @@ -38,6 +38,6 @@ ****************************************************************************/ // @snippet qxmlschemavalidator-schema -QXmlSchema* %0 = new QXmlSchema(%CPPSELF.schema()); -%PYARG_0 = %CONVERTTOPYTHON[QXmlSchema*](%0); +QXmlSchema *%0 = new QXmlSchema(%CPPSELF.schema()); +%PYARG_0 = %CONVERTTOPYTHON[QXmlSchema *](%0); // @snippet qxmlschemavalidator-schema diff --git a/sources/pyside2/PySide2/pysideqtesttouch.h b/sources/pyside2/PySide2/pysideqtesttouch.h index 60d3bbe25..115c7835e 100644 --- a/sources/pyside2/PySide2/pysideqtesttouch.h +++ b/sources/pyside2/PySide2/pysideqtesttouch.h @@ -66,28 +66,28 @@ namespace QTest if (commitWhenDestroyed) commit(); } - PySideQTouchEventSequence* press(int touchId, const QPoint &pt, QWindow *window = 0) + PySideQTouchEventSequence *press(int touchId, const QPoint &pt, QWindow *window = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(window, pt)); p.setState(Qt::TouchPointPressed); return this; } - PySideQTouchEventSequence* move(int touchId, const QPoint &pt, QWindow *window = 0) + PySideQTouchEventSequence *move(int touchId, const QPoint &pt, QWindow *window = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(window, pt)); p.setState(Qt::TouchPointMoved); return this; } - PySideQTouchEventSequence* release(int touchId, const QPoint &pt, QWindow *window = 0) + PySideQTouchEventSequence *release(int touchId, const QPoint &pt, QWindow *window = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(window, pt)); p.setState(Qt::TouchPointReleased); return this; } - PySideQTouchEventSequence* stationary(int touchId) + PySideQTouchEventSequence *stationary(int touchId) { QTouchEvent::TouchPoint &p = pointOrPreviousPoint(touchId); p.setState(Qt::TouchPointStationary); @@ -95,7 +95,7 @@ namespace QTest } #ifdef QT_WIDGETS_LIB - PySideQTouchEventSequence* press(int touchId, const QPoint &pt, QWidget *widget = 0) + PySideQTouchEventSequence *press(int touchId, const QPoint &pt, QWidget *widget = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(widget, pt)); @@ -103,7 +103,7 @@ namespace QTest return this; } - PySideQTouchEventSequence* move(int touchId, const QPoint &pt, QWidget *widget = 0) + PySideQTouchEventSequence *move(int touchId, const QPoint &pt, QWidget *widget = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(widget, pt)); @@ -111,7 +111,7 @@ namespace QTest return this; } - PySideQTouchEventSequence* release(int touchId, const QPoint &pt, QWidget *widget = 0) + PySideQTouchEventSequence *release(int touchId, const QPoint &pt, QWidget *widget = nullptr) { QTouchEvent::TouchPoint &p = point(touchId); p.setScreenPos(mapToScreen(widget, pt)); @@ -198,14 +198,14 @@ private: QTouchDevice *device; bool commitWhenDestroyed; #ifdef QT_WIDGETS_LIB - friend PySideQTouchEventSequence* generateTouchEvent(QWidget *, QTouchDevice*, bool); + friend PySideQTouchEventSequence *generateTouchEvent(QWidget *, QTouchDevice *, bool); #endif - friend PySideQTouchEventSequence* generateTouchEvent(QWindow *, QTouchDevice*, bool); + friend PySideQTouchEventSequence *generateTouchEvent(QWindow *, QTouchDevice *, bool); }; #ifdef QT_WIDGETS_LIB inline - PySideQTouchEventSequence* generateTouchEvent(QWidget *widget, + PySideQTouchEventSequence *generateTouchEvent(QWidget *widget, QTouchDevice *device, bool autoCommit = true) { @@ -213,7 +213,7 @@ private: } #endif inline - PySideQTouchEventSequence* generateTouchEvent(QWindow *window, + PySideQTouchEventSequence *generateTouchEvent(QWindow *window, QTouchDevice *device, bool autoCommit = true) { diff --git a/sources/pyside2/PySide2/qpytextobject.h b/sources/pyside2/PySide2/qpytextobject.h index ecdfa7fb5..1968ac385 100644 --- a/sources/pyside2/PySide2/qpytextobject.h +++ b/sources/pyside2/PySide2/qpytextobject.h @@ -54,9 +54,10 @@ class QPyTextObject : public QObject, public QTextObjectInterface Q_OBJECT Q_INTERFACES(QTextObjectInterface) public: - QPyTextObject(QObject* parent = 0) : QObject(parent) {} - void drawObject(QPainter* painter, const QRectF& rect, QTextDocument* doc, int posInDocument, const QTextFormat& format ) = 0; - QSizeF intrinsicSize(QTextDocument* doc, int posInDocument, const QTextFormat& format ) = 0; + QPyTextObject(QObject *parent = nullptr) : QObject(parent) {} + void drawObject(QPainter *painter, const QRectF &rect, QTextDocument *doc, + int posInDocument, const QTextFormat &format) = 0; + QSizeF intrinsicSize(QTextDocument *doc, int posInDocument, const QTextFormat &format) = 0; }; #endif diff --git a/sources/pyside2/libpyside/destroylistener.cpp b/sources/pyside2/libpyside/destroylistener.cpp index c6dc54713..319a126cf 100644 --- a/sources/pyside2/libpyside/destroylistener.cpp +++ b/sources/pyside2/libpyside/destroylistener.cpp @@ -42,7 +42,7 @@ #include -PySide::DestroyListener* PySide::DestroyListener::m_instance = 0; +PySide::DestroyListener *PySide::DestroyListener::m_instance = nullptr; namespace PySide { @@ -53,7 +53,7 @@ struct DestroyListenerPrivate }; -DestroyListener* DestroyListener::instance() +DestroyListener *DestroyListener::instance() { if (!m_instance) m_instance = new DestroyListener(0); @@ -71,19 +71,19 @@ void DestroyListener::destroy() void DestroyListener::listen(QObject *obj) { - SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(obj); + SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(obj); if (!wrapper) // avoid problem with multiple inheritance return; if (Py_IsInitialized() == 0) onObjectDestroyed(obj); else - QObject::connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(onObjectDestroyed(QObject*)), Qt::DirectConnection); + QObject::connect(obj, SIGNAL(destroyed(QObject *)), this, SLOT(onObjectDestroyed(QObject *)), Qt::DirectConnection); } -void DestroyListener::onObjectDestroyed(QObject* obj) +void DestroyListener::onObjectDestroyed(QObject *obj) { - SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(obj); + SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(obj); if (wrapper) //make sure the object exists before destroy Shiboken::Object::destroy(wrapper, obj); } diff --git a/sources/pyside2/libpyside/destroylistener.h b/sources/pyside2/libpyside/destroylistener.h index b1a0597c5..dedcca662 100644 --- a/sources/pyside2/libpyside/destroylistener.h +++ b/sources/pyside2/libpyside/destroylistener.h @@ -52,16 +52,16 @@ class PYSIDE_API DestroyListener : public QObject { Q_OBJECT public: - PYSIDE_DEPRECATED(static DestroyListener* instance()); + PYSIDE_DEPRECATED(static DestroyListener *instance()); static void destroy(); - void listen(QObject* obj); + void listen(QObject *obj); public Q_SLOTS: - void onObjectDestroyed(QObject* obj); + void onObjectDestroyed(QObject *obj); private: - static DestroyListener* m_instance; - DestroyListenerPrivate* m_d; + static DestroyListener *m_instance; + DestroyListenerPrivate *m_d; DestroyListener(QObject *parent); ~DestroyListener() override; }; diff --git a/sources/pyside2/libpyside/globalreceiverv2.cpp b/sources/pyside2/libpyside/globalreceiverv2.cpp index 43ce50a75..170cbf22f 100644 --- a/sources/pyside2/libpyside/globalreceiverv2.cpp +++ b/sources/pyside2/libpyside/globalreceiverv2.cpp @@ -62,27 +62,27 @@ class DynamicSlotDataV2 { Q_DISABLE_COPY(DynamicSlotDataV2) public: - DynamicSlotDataV2(PyObject* callback, GlobalReceiverV2* parent); + DynamicSlotDataV2(PyObject *callback, GlobalReceiverV2 *parent); ~DynamicSlotDataV2(); - int addSlot(const char* signature); - int id(const char* signature) const; - PyObject* callback(); + int addSlot(const char *signature); + int id(const char *signature) const; + PyObject *callback(); QByteArray hash() const; void notify(); - static void onCallbackDestroyed(void* data); + static void onCallbackDestroyed(void *data); static QByteArray hash(PyObject *callback); private: bool m_isMethod; - PyObject* m_callback; - PyObject* m_pythonSelf; - PyObject* m_pyClass; - PyObject* m_weakRef; + PyObject *m_callback; + PyObject *m_pythonSelf; + PyObject *m_pyClass; + PyObject *m_weakRef; QMap m_signatures; - GlobalReceiverV2* m_parent; + GlobalReceiverV2 *m_parent; QByteArray m_hash; }; @@ -90,7 +90,7 @@ class DynamicSlotDataV2 using namespace PySide; -DynamicSlotDataV2::DynamicSlotDataV2(PyObject* callback, GlobalReceiverV2* parent) +DynamicSlotDataV2::DynamicSlotDataV2(PyObject *callback, GlobalReceiverV2 *parent) : m_pythonSelf(0), m_pyClass(0), m_weakRef(0), m_parent(parent) { Shiboken::GilState gil; @@ -124,7 +124,7 @@ QByteArray DynamicSlotDataV2::hash() const return m_hash; } -QByteArray DynamicSlotDataV2::hash(PyObject* callback) +QByteArray DynamicSlotDataV2::hash(PyObject *callback) { Shiboken::GilState gil; if (PyMethod_Check(callback)) { @@ -134,9 +134,9 @@ QByteArray DynamicSlotDataV2::hash(PyObject* callback) return QByteArray::number(qlonglong(PyObject_Hash(callback))); } -PyObject* DynamicSlotDataV2::callback() +PyObject *DynamicSlotDataV2::callback() { - PyObject* callback = m_callback; + PyObject *callback = m_callback; //create a callback based on method data if (m_isMethod) @@ -151,13 +151,13 @@ PyObject* DynamicSlotDataV2::callback() return callback; } -int DynamicSlotDataV2::id(const char* signature) const +int DynamicSlotDataV2::id(const char *signature) const { const auto it = m_signatures.constFind(signature); return it != m_signatures.cend() ? it.value() : -1; } -int DynamicSlotDataV2::addSlot(const char* signature) +int DynamicSlotDataV2::addSlot(const char *signature) { int index = id(signature); if (index == -1) @@ -167,7 +167,7 @@ int DynamicSlotDataV2::addSlot(const char* signature) void DynamicSlotDataV2::onCallbackDestroyed(void *data) { - DynamicSlotDataV2* self = reinterpret_cast(data); + auto self = reinterpret_cast(data); self->m_weakRef = 0; Py_BEGIN_ALLOW_THREADS delete self->m_parent; @@ -222,12 +222,12 @@ GlobalReceiverV2::~GlobalReceiverV2() delete data; } -int GlobalReceiverV2::addSlot(const char* signature) +int GlobalReceiverV2::addSlot(const char *signature) { return m_data->addSlot(signature); } -void GlobalReceiverV2::incRef(const QObject* link) +void GlobalReceiverV2::incRef(const QObject *link) { if (link) { if (!m_refs.contains(link)) { @@ -247,7 +247,7 @@ void GlobalReceiverV2::incRef(const QObject* link) } } -void GlobalReceiverV2::decRef(const QObject* link) +void GlobalReceiverV2::decRef(const QObject *link) { if (m_refs.empty()) return; @@ -273,7 +273,7 @@ void GlobalReceiverV2::decRef(const QObject* link) } -int GlobalReceiverV2::refCount(const QObject* link) const +int GlobalReceiverV2::refCount(const QObject *link) const { if (link) return m_refs.count(link); @@ -283,7 +283,7 @@ int GlobalReceiverV2::refCount(const QObject* link) const void GlobalReceiverV2::notify() { - const auto objSet = QSet::fromList(m_refs); + const auto objSet = QSet::fromList(m_refs); Py_BEGIN_ALLOW_THREADS for (const QObject *o : objSet) { QMetaObject::disconnect(o, DESTROY_SIGNAL_ID, this, DESTROY_SLOT_ID); @@ -297,17 +297,17 @@ QByteArray GlobalReceiverV2::hash() const return m_data->hash(); } -QByteArray GlobalReceiverV2::hash(PyObject* callback) +QByteArray GlobalReceiverV2::hash(PyObject *callback) { return DynamicSlotDataV2::hash(callback); } -const QMetaObject* GlobalReceiverV2::metaObject() const +const QMetaObject *GlobalReceiverV2::metaObject() const { return const_cast(this)->m_metaObject.update(); } -int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void** args) +int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void **args) { Shiboken::GilState gil; Q_ASSERT(call == QMetaObject::InvokeMetaMethod); @@ -328,7 +328,7 @@ int GlobalReceiverV2::qt_metacall(QMetaObject::Call call, int id, void** args) if (id == DESTROY_SLOT_ID) { if (m_refs.empty()) return -1; - QObject *obj = *reinterpret_cast(args[1]); + auto obj = *reinterpret_cast(args[1]); incRef(); //keep the object live (safe ref) m_refs.removeAll(obj); // remove all refs to this object decRef(); //remove the safe ref diff --git a/sources/pyside2/libpyside/globalreceiverv2.h b/sources/pyside2/libpyside/globalreceiverv2.h index b92be93a8..433f587a9 100644 --- a/sources/pyside2/libpyside/globalreceiverv2.h +++ b/sources/pyside2/libpyside/globalreceiverv2.h @@ -82,8 +82,8 @@ public: /** * Reimplemented function from QObject **/ - int qt_metacall(QMetaObject::Call call, int id, void** args) override; - const QMetaObject* metaObject() const override; + int qt_metacall(QMetaObject::Call call, int id, void **args) override; + const QMetaObject *metaObject() const override; /** * Add a extra slot to this object @@ -91,7 +91,7 @@ public: * @param signature The signature of the slot to be added * @return The index of this slot on metaobject **/ - int addSlot(const char* signature); + int addSlot(const char *signature); /** * Notify to GlobalReceiver about when a new connection was made @@ -103,14 +103,14 @@ public: * * @param link This is a optional paramenter used to link the ref to some QObject life **/ - void incRef(const QObject* link = 0); + void incRef(const QObject *link = nullptr); /** * Used to decrement the reference of the GlobalReceiver object * * @param link This is a optional paramenter used to dismiss the link ref to some QObject **/ - void decRef(const QObject* link = 0); + void decRef(const QObject *link = nullptr); /* * Return the count of refs which the GlobalReceiver has @@ -118,7 +118,7 @@ public: * @param link If any QObject was passed, the function return the number of references relative to this 'link' object * @return The number of references **/ - int refCount(const QObject* link) const; + int refCount(const QObject *link) const; /** * Use to retrieve the unique hash of this GlobalReceiver object @@ -133,7 +133,7 @@ public: * @param callback The Python callable object used to calculate the id * @return a string with a unique id based on GlobalReceiver contents **/ - static QByteArray hash(PyObject* callback); + static QByteArray hash(PyObject *callback); const MetaObjectBuilder &metaObjectBuilder() const { return m_metaObject; } MetaObjectBuilder &metaObjectBuilder() { return m_metaObject; } @@ -141,7 +141,7 @@ public: private: MetaObjectBuilder m_metaObject; DynamicSlotDataV2 *m_data; - QList m_refs; + QList m_refs; SharedMap m_sharedMap; }; diff --git a/sources/pyside2/libpyside/pyside.cpp b/sources/pyside2/libpyside/pyside.cpp index fff28a9e7..9ee20f461 100644 --- a/sources/pyside2/libpyside/pyside.cpp +++ b/sources/pyside2/libpyside/pyside.cpp @@ -72,7 +72,7 @@ #include static QStack cleanupFunctionList; -static void* qobjectNextAddr; +static void *qobjectNextAddr; QT_BEGIN_NAMESPACE extern bool qRegisterResourceData(int, const unsigned char *, const unsigned char *, @@ -94,7 +94,7 @@ void init(PyObject *module) SignalManager::instance(); } -static bool _setProperty(PyObject* qObj, PyObject *name, PyObject *value, bool *accept) +static bool _setProperty(PyObject *qObj, PyObject *name, PyObject *value, bool *accept) { QByteArray propName(Shiboken::String::toCString(name)); propName[0] = std::toupper(propName[0]); @@ -112,14 +112,14 @@ static bool _setProperty(PyObject* qObj, PyObject *name, PyObject *value, bool * Shiboken::AutoDecRef attr(PyObject_GenericGetAttr(qObj, name)); if (PySide::Property::checkType(attr)) { *accept = true; - if (PySide::Property::setValue(reinterpret_cast(attr.object()), qObj, value) < 0) + if (PySide::Property::setValue(reinterpret_cast(attr.object()), qObj, value) < 0) return false; } } return true; } -bool fillQtProperties(PyObject* qObj, const QMetaObject* metaObj, PyObject* kwds, const char** blackList, unsigned int blackListSize) +bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds, const char **blackList, unsigned int blackListSize) { PyObject *key, *value; @@ -170,11 +170,11 @@ void runCleanupFunctions() PySide::DestroyListener::destroy(); } -static void destructionVisitor(SbkObject* pyObj, void* data) +static void destructionVisitor(SbkObject *pyObj, void *data) { - void** realData = reinterpret_cast(data); - SbkObject* pyQApp = reinterpret_cast(realData[0]); - PyTypeObject* pyQObjectType = reinterpret_cast(realData[1]); + auto realData = reinterpret_cast(data); + auto pyQApp = reinterpret_cast(realData[0]); + auto pyQObjectType = reinterpret_cast(realData[1]); if (pyObj != pyQApp && PyObject_TypeCheck(pyObj, pyQObjectType)) { if (Shiboken::Object::hasOwnership(pyObj) && Shiboken::Object::isValid(pyObj, false)) { @@ -190,17 +190,17 @@ static void destructionVisitor(SbkObject* pyObj, void* data) void destroyQCoreApplication() { - QCoreApplication* app = QCoreApplication::instance(); + QCoreApplication *app = QCoreApplication::instance(); if (!app) return; SignalManager::instance().clear(); - Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); - SbkObject* pyQApp = bm.retrieveWrapper(app); - PyTypeObject* pyQObjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); + Shiboken::BindingManager &bm = Shiboken::BindingManager::instance(); + SbkObject *pyQApp = bm.retrieveWrapper(app); + PyTypeObject *pyQObjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); assert(pyQObjectType); - void* data[2] = {pyQApp, pyQObjectType}; + void *data[2] = {pyQApp, pyQObjectType}; bm.visitAllPyObjects(&destructionVisitor, &data); // in the end destroy app @@ -214,26 +214,26 @@ void destroyQCoreApplication() MakeSingletonQAppWrapper(NULL); } -std::size_t getSizeOfQObject(SbkObjectType* type) +std::size_t getSizeOfQObject(SbkObjectType *type) { return retrieveTypeUserData(type)->cppObjSize; } -void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base, std::size_t cppObjSize) +void initDynamicMetaObject(SbkObjectType *type, const QMetaObject *base, std::size_t cppObjSize) { //create DynamicMetaObject based on python type auto userData = - new TypeUserData(reinterpret_cast(type), base, cppObjSize); + new TypeUserData(reinterpret_cast(type), base, cppObjSize); userData->mo.update(); Shiboken::ObjectType::setTypeUserData(type, userData, Shiboken::callCppDestructor); //initialize staticQMetaObject property void *metaObjectPtr = const_cast(userData->mo.update()); - static SbkConverter* converter = Shiboken::Conversions::getConverter("QMetaObject"); + static SbkConverter *converter = Shiboken::Conversions::getConverter("QMetaObject"); if (!converter) return; Shiboken::AutoDecRef pyMetaObject(Shiboken::Conversions::pointerToPython(converter, metaObjectPtr)); - PyObject_SetAttrString(reinterpret_cast(type), "staticMetaObject", pyMetaObject); + PyObject_SetAttrString(reinterpret_cast(type), "staticMetaObject", pyMetaObject); } TypeUserData *retrieveTypeUserData(SbkObjectType *sbkTypeObj) @@ -266,23 +266,23 @@ const QMetaObject *retrieveMetaObject(PyObject *pyObj) return retrieveMetaObject(pyTypeObj); } -void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base) +void initDynamicMetaObject(SbkObjectType *type, const QMetaObject *base) { initDynamicMetaObject(type, base, 0); } void initQObjectSubType(SbkObjectType *type, PyObject *args, PyObject * /* kwds */) { - PyTypeObject* qObjType = Shiboken::Conversions::getPythonTypeObject("QObject*"); + PyTypeObject *qObjType = Shiboken::Conversions::getPythonTypeObject("QObject*"); QByteArray className(Shiboken::String::toCString(PyTuple_GET_ITEM(args, 0))); - PyObject* bases = PyTuple_GET_ITEM(args, 1); + PyObject *bases = PyTuple_GET_ITEM(args, 1); int numBases = PyTuple_GET_SIZE(bases); TypeUserData *userData = nullptr; for (int i = 0; i < numBases; ++i) { - PyTypeObject* base = reinterpret_cast(PyTuple_GET_ITEM(bases, i)); + auto base = reinterpret_cast(PyTuple_GET_ITEM(bases, i)); if (PyType_IsSubtype(base, qObjType)) { userData = retrieveTypeUserData(base); break; @@ -295,14 +295,14 @@ void initQObjectSubType(SbkObjectType *type, PyObject *args, PyObject * /* kwds initDynamicMetaObject(type, userData->mo.update(), userData->cppObjSize); } -PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* name) +PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name) { - PyObject* attr = PyObject_GenericGetAttr(self, name); - if (!Shiboken::Object::isValid(reinterpret_cast(self), false)) + PyObject *attr = PyObject_GenericGetAttr(self, name); + if (!Shiboken::Object::isValid(reinterpret_cast(self), false)) return attr; if (attr && Property::checkType(attr)) { - PyObject *value = Property::getValue(reinterpret_cast(attr), self); + PyObject *value = Property::getValue(reinterpret_cast(attr), self); Py_DECREF(attr); if (!value) return 0; @@ -312,17 +312,17 @@ PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* nam //mutate native signals to signal instance type if (attr && PyObject_TypeCheck(attr, PySideSignalTypeF())) { - PyObject* signal = reinterpret_cast(Signal::initialize(reinterpret_cast(attr), name, self)); - PyObject_SetAttr(self, name, reinterpret_cast(signal)); + PyObject *signal = reinterpret_cast(Signal::initialize(reinterpret_cast(attr), name, self)); + PyObject_SetAttr(self, name, reinterpret_cast(signal)); return signal; } //search on metaobject (avoid internal attributes started with '__') if (!attr) { - const char* cname = Shiboken::String::toCString(name); + const char *cname = Shiboken::String::toCString(name); uint cnameLen = qstrlen(cname); if (std::strncmp("__", cname, 2)) { - const QMetaObject* metaObject = cppSelf->metaObject(); + const QMetaObject *metaObject = cppSelf->metaObject(); //signal QList signalList; for(int i=0, i_max = metaObject->methodCount(); i < i_max; i++) { @@ -334,7 +334,7 @@ PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* nam if (method.methodType() == QMetaMethod::Signal) { signalList.append(method); } else { - PySideMetaFunction* func = MetaFunction::newObject(cppSelf, i); + PySideMetaFunction *func = MetaFunction::newObject(cppSelf, i); if (func) { PyObject *result = reinterpret_cast(func); PyObject_SetAttr(self, name, result); @@ -344,7 +344,7 @@ PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* nam } } if (!signalList.empty()) { - PyObject* pySignal = reinterpret_cast(Signal::newObjectFromMethod(self, signalList)); + PyObject *pySignal = reinterpret_cast(Signal::newObjectFromMethod(self, signalList)); PyObject_SetAttr(self, name, pySignal); return pySignal; } @@ -353,24 +353,24 @@ PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* nam return attr; } -bool inherits(PyTypeObject* objType, const char* class_name) +bool inherits(PyTypeObject *objType, const char *class_name) { if (strcmp(objType->tp_name, class_name) == 0) return true; - PyTypeObject* base = objType->tp_base; + PyTypeObject *base = objType->tp_base; if (base == 0) return false; return inherits(base, class_name); } -void* nextQObjectMemoryAddr() +void *nextQObjectMemoryAddr() { return qobjectNextAddr; } -void setNextQObjectMemoryAddr(void* addr) +void setNextQObjectMemoryAddr(void *addr) { qobjectNextAddr = addr; } @@ -379,27 +379,27 @@ void setNextQObjectMemoryAddr(void* addr) // A QSharedPointer is used with a deletion function to invalidate a pointer // when the property value is cleared. This should be a QSharedPointer with -// a void* pointer, but that isn't allowed +// a void *pointer, but that isn't allowed typedef char any_t; Q_DECLARE_METATYPE(QSharedPointer); namespace PySide { -static void invalidatePtr(any_t* object) +static void invalidatePtr(any_t *object) { Shiboken::GilState state; - SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(object); + SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(object); if (wrapper != NULL) Shiboken::BindingManager::instance().releaseWrapper(wrapper); } static const char invalidatePropertyName[] = "_PySideInvalidatePtr"; -PyObject* getWrapperForQObject(QObject* cppSelf, SbkObjectType* sbk_type) +PyObject *getWrapperForQObject(QObject *cppSelf, SbkObjectType *sbk_type) { - PyObject* pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppSelf)); + PyObject *pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppSelf)); if (pyOut) { Py_INCREF(pyOut); return pyOut; @@ -410,7 +410,7 @@ PyObject* getWrapperForQObject(QObject* cppSelf, SbkObjectType* sbk_type) // set and check if it's created after the set call QVariant existing = cppSelf->property(invalidatePropertyName); if (!existing.isValid()) { - QSharedPointer shared_with_del(reinterpret_cast(cppSelf), invalidatePtr); + QSharedPointer shared_with_del(reinterpret_cast(cppSelf), invalidatePtr); cppSelf->setProperty(invalidatePropertyName, QVariant::fromValue(shared_with_del)); pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppSelf)); if (pyOut) { @@ -419,7 +419,7 @@ PyObject* getWrapperForQObject(QObject* cppSelf, SbkObjectType* sbk_type) } } - const char* typeName = typeid(*cppSelf).name(); + const char *typeName = typeid(*cppSelf).name(); pyOut = Shiboken::Object::newObject(sbk_type, cppSelf, false, false, typeName); return pyOut; @@ -509,7 +509,7 @@ bool registerInternalQtConf() #if PY_MAJOR_VERSION >= 3 QString::fromWCharArray(Py_GetProgramFullPath()); #else - // Python 2 unfortunately returns a char* array instead of a wchar*, which means that on + // Python 2 unfortunately returns a char * array instead of a wchar *, which means that on // Windows if the executable path contains unicode characters, the returned path will be // invalid. We can't use QCoreApplication::applicationFilePath because it requires an // existing QCoreApplication instance despite being a static method. diff --git a/sources/pyside2/libpyside/pyside.h b/sources/pyside2/libpyside/pyside.h index b53048eba..1529d79c9 100644 --- a/sources/pyside2/libpyside/pyside.h +++ b/sources/pyside2/libpyside/pyside.h @@ -76,7 +76,7 @@ inline uint hash(const T& value) * \param kwds key->value dictonary. * \return True if everything goes well, false with a Python error setted otherwise. */ -PYSIDE_API bool fillQtProperties(PyObject* qObj, const QMetaObject* metaObj, PyObject* kwds, const char** blackList, unsigned int blackListSize); +PYSIDE_API bool fillQtProperties(PyObject *qObj, const QMetaObject *metaObj, PyObject *kwds, const char **blackList, unsigned int blackListSize); /** * If the type \p T was registered on Qt meta type system with Q_DECLARE_METATYPE macro, this class will initialize @@ -99,13 +99,13 @@ template struct initQtMetaType { }; -PYSIDE_DEPRECATED(PYSIDE_API void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base)); -PYSIDE_API void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base, +PYSIDE_DEPRECATED(PYSIDE_API void initDynamicMetaObject(SbkObjectType *type, const QMetaObject *base)); +PYSIDE_API void initDynamicMetaObject(SbkObjectType *type, const QMetaObject *base, std::size_t cppObjSize); -PYSIDE_API void initQObjectSubType(SbkObjectType* type, PyObject* args, PyObject* kwds); +PYSIDE_API void initQObjectSubType(SbkObjectType *type, PyObject *args, PyObject *kwds); /// Return the size in bytes of a type that inherits QObject. -PYSIDE_API std::size_t getSizeOfQObject(SbkObjectType* type); +PYSIDE_API std::size_t getSizeOfQObject(SbkObjectType *type); typedef void (*CleanupFunction)(void); @@ -127,7 +127,7 @@ PYSIDE_API void destroyQCoreApplication(); * \param name Name of the argument which the function will try retrieve from MetaData * \return The Python object which contains the Data obtained in metaObject or the Python attribute related with name */ -PYSIDE_API PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, PyObject* name); +PYSIDE_API PyObject *getMetaDataFromQObject(QObject *cppSelf, PyObject *self, PyObject *name); /** * Check if self inherits from class_name @@ -135,12 +135,12 @@ PYSIDE_API PyObject* getMetaDataFromQObject(QObject* cppSelf, PyObject* self, Py * \param class_name strict with the class name * \return Returns true if self object inherits from class_name, otherwise returns false */ -PYSIDE_API bool inherits(PyTypeObject* self, const char* class_name); +PYSIDE_API bool inherits(PyTypeObject *self, const char *class_name); -PYSIDE_API void* nextQObjectMemoryAddr(); -PYSIDE_API void setNextQObjectMemoryAddr(void* addr); +PYSIDE_API void *nextQObjectMemoryAddr(); +PYSIDE_API void setNextQObjectMemoryAddr(void *addr); -PYSIDE_API PyObject* getWrapperForQObject(QObject* cppSelf, SbkObjectType* sbk_type); +PYSIDE_API PyObject *getWrapperForQObject(QObject *cppSelf, SbkObjectType *sbk_type); #ifdef PYSIDE_QML_SUPPORT // Used by QtQuick module to notify QtQml that custom QtQuick items can be registered. diff --git a/sources/pyside2/libpyside/pysideclassinfo.cpp b/sources/pyside2/libpyside/pysideclassinfo.cpp index 4edf0fa91..bf2a1307f 100644 --- a/sources/pyside2/libpyside/pysideclassinfo.cpp +++ b/sources/pyside2/libpyside/pysideclassinfo.cpp @@ -51,10 +51,10 @@ extern "C" { -static PyObject* classInfoTpNew(PyTypeObject* subtype, PyObject* args, PyObject* kwds); -static int classInfoTpInit(PyObject*, PyObject*, PyObject*); -static void classInfoFree(void*); -static PyObject* classCall(PyObject*, PyObject*, PyObject*); +static PyObject *classInfoTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds); +static int classInfoTpInit(PyObject *, PyObject *, PyObject *); +static void classInfoFree(void *); +static PyObject *classCall(PyObject *, PyObject *, PyObject *); static PyType_Slot PySideClassInfoType_slots[] = { {Py_tp_call, (void *)classCall}, @@ -89,8 +89,8 @@ PyObject *classCall(PyObject *self, PyObject *args, PyObject * /* kw */) return 0; } - PySideClassInfo* data = reinterpret_cast(self); - PySideClassInfoPrivate* pData = data->d; + PySideClassInfo *data = reinterpret_cast(self); + PySideClassInfoPrivate *pData = data->d; if (pData->m_alreadyWrapped) { PyErr_SetString(PyExc_TypeError, "This instance of ClassInfo() was already used to wrap an object"); @@ -106,7 +106,7 @@ PyObject *classCall(PyObject *self, PyObject *args, PyObject * /* kw */) return 0; } - PyTypeObject *klassType = reinterpret_cast(klass); + PyTypeObject *klassType = reinterpret_cast(klass); if (Shiboken::ObjectType::checkType(klassType)) { if (auto userData = PySide::retrieveTypeUserData(klassType)) { PySide::MetaObjectBuilder &mo = userData->mo; @@ -127,7 +127,7 @@ PyObject *classCall(PyObject *self, PyObject *args, PyObject * /* kw */) static PyObject *classInfoTpNew(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */) { - PySideClassInfo* me = reinterpret_cast(subtype->tp_alloc(subtype, 0)); + PySideClassInfo *me = reinterpret_cast(subtype->tp_alloc(subtype, 0)); me->d = new PySideClassInfoPrivate; me->d->m_alreadyWrapped = false; @@ -135,18 +135,18 @@ static PyObject *classInfoTpNew(PyTypeObject *subtype, PyObject * /* args */, Py return reinterpret_cast(me); } -int classInfoTpInit(PyObject* self, PyObject* args, PyObject* kwds) +int classInfoTpInit(PyObject *self, PyObject *args, PyObject *kwds) { if (PyTuple_Check(args) && PyTuple_Size(args) > 0) { PyErr_Format(PyExc_TypeError, "ClassInfo() takes exactly 0 positional arguments (%zd given)", PyTuple_Size(args)); return -1; } - PySideClassInfo* data = reinterpret_cast(self); - PySideClassInfoPrivate* pData = data->d; + PySideClassInfo *data = reinterpret_cast(self); + PySideClassInfoPrivate *pData = data->d; - PyObject* key; - PyObject* value; + PyObject *key; + PyObject *value; Py_ssize_t pos = 0; // PyDict_Next causes a segfault if kwds is empty @@ -166,8 +166,8 @@ int classInfoTpInit(PyObject* self, PyObject* args, PyObject* kwds) void classInfoFree(void *self) { - PyObject* pySelf = reinterpret_cast(self); - PySideClassInfo* data = reinterpret_cast(self); + auto pySelf = reinterpret_cast(self); + auto data = reinterpret_cast(self); delete data->d; Py_TYPE(pySelf)->tp_base->tp_free(self); @@ -179,7 +179,7 @@ void classInfoFree(void *self) namespace PySide { namespace ClassInfo { -void init(PyObject* module) +void init(PyObject *module) { if (PyType_Ready(PySideClassInfoTypeF()) < 0) return; @@ -188,14 +188,14 @@ void init(PyObject* module) PyModule_AddObject(module, CLASSINFO_CLASS_NAME, reinterpret_cast(PySideClassInfoTypeF())); } -bool checkType(PyObject* pyObj) +bool checkType(PyObject *pyObj) { if (pyObj) return PyType_IsSubtype(Py_TYPE(pyObj), PySideClassInfoTypeF()); return false; } -QMap getMap(PySideClassInfo* obj) +QMap getMap(PySideClassInfo *obj) { return obj->d->m_data; } diff --git a/sources/pyside2/libpyside/pysidemetafunction.cpp b/sources/pyside2/libpyside/pysidemetafunction.cpp index 4cdc7ec16..346117201 100644 --- a/sources/pyside2/libpyside/pysidemetafunction.cpp +++ b/sources/pyside2/libpyside/pysidemetafunction.cpp @@ -49,13 +49,13 @@ extern "C" struct PySideMetaFunctionPrivate { - QObject* qobject; + QObject *qobject; int methodIndex; }; //methods -static void functionFree(void*); -static PyObject* functionCall(PyObject*, PyObject*, PyObject*); +static void functionFree(void *); +static PyObject *functionCall(PyObject *, PyObject *, PyObject *); static PyType_Slot PySideMetaFunctionType_slots[] = { {Py_tp_call, (void *)functionCall}, @@ -83,15 +83,15 @@ PyTypeObject *PySideMetaFunctionTypeF(void) void functionFree(void *self) { - PySideMetaFunction* function = reinterpret_cast(self); + PySideMetaFunction *function = reinterpret_cast(self); delete function->d; } PyObject *functionCall(PyObject *self, PyObject *args, PyObject * /* kw */) { - PySideMetaFunction* function = reinterpret_cast(self); + PySideMetaFunction *function = reinterpret_cast(self); - PyObject* retVal; + PyObject *retVal; if (!PySide::MetaFunction::call(function->d->qobject, function->d->methodIndex, args, &retVal)) return 0; return retVal; @@ -101,7 +101,7 @@ PyObject *functionCall(PyObject *self, PyObject *args, PyObject * /* kw */) namespace PySide { namespace MetaFunction { -void init(PyObject* module) +void init(PyObject *module) { if (PyType_Ready(PySideMetaFunctionTypeF()) < 0) return; @@ -109,7 +109,7 @@ void init(PyObject* module) PyModule_AddObject(module, "MetaFunction", reinterpret_cast(PySideMetaFunctionTypeF())); } -PySideMetaFunction* newObject(QObject* source, int methodIndex) +PySideMetaFunction *newObject(QObject *source, int methodIndex) { if (methodIndex >= source->metaObject()->methodCount()) return 0; @@ -117,7 +117,7 @@ PySideMetaFunction* newObject(QObject* source, int methodIndex) QMetaMethod method = source->metaObject()->method(methodIndex); if ((method.methodType() == QMetaMethod::Slot) || (method.methodType() == QMetaMethod::Method)) { - PySideMetaFunction* function = PyObject_New(PySideMetaFunction, PySideMetaFunctionTypeF()); + PySideMetaFunction *function = PyObject_New(PySideMetaFunction, PySideMetaFunctionTypeF()); function->d = new PySideMetaFunctionPrivate(); function->d->qobject = source; function->d->methodIndex = methodIndex; @@ -126,7 +126,7 @@ PySideMetaFunction* newObject(QObject* source, int methodIndex) return 0; } -bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal) +bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal) { QMetaMethod method = self->metaObject()->method(methodIndex); @@ -150,11 +150,11 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal) return false; } - QVariant* methValues = new QVariant[numArgs]; - void** methArgs = new void*[numArgs]; + QVariant *methValues = new QVariant[numArgs]; + void **methArgs = new void *[numArgs]; // Prepare room for return type - const char* returnType = method.typeName(); + const char *returnType = method.typeName(); if (returnType && std::strcmp("void", returnType)) argTypes.prepend(returnType); else @@ -162,7 +162,7 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal) int i; for (i = 0; i < numArgs; ++i) { - const QByteArray& typeName = argTypes[i]; + const QByteArray &typeName = argTypes.at(i); // This must happen only when the method hasn't return type. if (typeName.isEmpty()) { methArgs[i] = 0; @@ -204,7 +204,7 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal) if (retVal) { if (methArgs[0]) { - static SbkConverter* qVariantTypeConverter = Shiboken::Conversions::getConverter("QVariant"); + static SbkConverter *qVariantTypeConverter = Shiboken::Conversions::getConverter("QVariant"); Q_ASSERT(qVariantTypeConverter); *retVal = Shiboken::Conversions::copyToPython(qVariantTypeConverter, &methValues[0]); } else { diff --git a/sources/pyside2/libpyside/pysidemetafunction.h b/sources/pyside2/libpyside/pysidemetafunction.h index 1085ecb5e..f7cc5307b 100644 --- a/sources/pyside2/libpyside/pysidemetafunction.h +++ b/sources/pyside2/libpyside/pysidemetafunction.h @@ -54,7 +54,7 @@ extern "C" struct PYSIDE_API PySideMetaFunction { PyObject_HEAD - PySideMetaFunctionPrivate* d; + PySideMetaFunctionPrivate *d; }; }; //extern "C" @@ -67,7 +67,7 @@ namespace PySide { namespace MetaFunction { * @param methodIndex The index of this function on MetaObject * @return Return a new reference of PySideMetaFunction **/ -PYSIDE_API PySideMetaFunction* newObject(QObject* obj, int methodIndex); +PYSIDE_API PySideMetaFunction *newObject(QObject *obj, int methodIndex); } //namespace MetaFunction } //namespace PySide diff --git a/sources/pyside2/libpyside/pysidemetafunction_p.h b/sources/pyside2/libpyside/pysidemetafunction_p.h index 442e05ea7..c67233857 100644 --- a/sources/pyside2/libpyside/pysidemetafunction_p.h +++ b/sources/pyside2/libpyside/pysidemetafunction_p.h @@ -50,11 +50,11 @@ QT_END_NAMESPACE namespace PySide { namespace MetaFunction { - void init(PyObject* module); + void init(PyObject *module); /** * Does a Qt metacall on a QObject */ - bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal = 0); + bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal = nullptr); } //namespace MetaFunction } //namespace PySide diff --git a/sources/pyside2/libpyside/pysideproperty.cpp b/sources/pyside2/libpyside/pysideproperty.cpp index c48a6f882..a2bf5fd2b 100644 --- a/sources/pyside2/libpyside/pysideproperty.cpp +++ b/sources/pyside2/libpyside/pysideproperty.cpp @@ -51,16 +51,16 @@ extern "C" { -static PyObject* qpropertyTpNew(PyTypeObject* subtype, PyObject* args, PyObject* kwds); -static int qpropertyTpInit(PyObject*, PyObject*, PyObject*); -static void qpropertyDeAlloc(PyObject* self); +static PyObject *qpropertyTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds); +static int qpropertyTpInit(PyObject *, PyObject *, PyObject *); +static void qpropertyDeAlloc(PyObject *self); //methods -static PyObject* qPropertyCall(PyObject*, PyObject*, PyObject*); -static PyObject* qPropertySetter(PyObject*, PyObject*); -static PyObject* qPropertyGetter(PyObject*, PyObject*); -static int qpropertyTraverse(PyObject* self, visitproc visit, void* arg); -static int qpropertyClear(PyObject* self); +static PyObject *qPropertyCall(PyObject *, PyObject *, PyObject *); +static PyObject *qPropertySetter(PyObject *, PyObject *); +static PyObject *qPropertyGetter(PyObject *, PyObject *); +static int qpropertyTraverse(PyObject *self, visitproc visit, void *arg); +static int qpropertyClear(PyObject *self); static PyMethodDef PySidePropertyMethods[] = { {"setter", (PyCFunction)qPropertySetter, METH_O, 0}, @@ -98,7 +98,7 @@ PyTypeObject *PySidePropertyTypeF(void) return type; } -static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Call call, void** args) +static void qpropertyMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, void **args) { Shiboken::Conversions::SpecificConverter converter(pp->d->typeName); Q_ASSERT(converter); @@ -109,7 +109,7 @@ static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::C case QMetaObject::ReadProperty: { Shiboken::GilState gil; - PyObject* value = PySide::Property::getValue(pp, self); + PyObject *value = PySide::Property::getValue(pp, self); if (value) { converter.toCpp(value, args[0]); Py_DECREF(value); @@ -150,16 +150,16 @@ static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::C static PyObject *qpropertyTpNew(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */) { - PySideProperty* me = reinterpret_cast(subtype->tp_alloc(subtype, 0)); + PySideProperty *me = reinterpret_cast(subtype->tp_alloc(subtype, 0)); me->d = new PySidePropertyPrivate; return reinterpret_cast(me); } -int qpropertyTpInit(PyObject* self, PyObject* args, PyObject* kwds) +int qpropertyTpInit(PyObject *self, PyObject *args, PyObject *kwds) { - PyObject* type = 0; - PySideProperty* data = reinterpret_cast(self); - PySidePropertyPrivate* pData = data->d; + PyObject *type = nullptr; + auto data = reinterpret_cast(self); + PySidePropertyPrivate *pData = data->d; pData->metaCallHandler = &qpropertyMetaCall; static const char *kwlist[] = {"type", "fget", "fset", "freset", "fdel", "doc", "notify", @@ -169,7 +169,7 @@ int qpropertyTpInit(PyObject* self, PyObject* args, PyObject* kwds) if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOOOsObbbbbb:QtCore.QProperty", - const_cast(kwlist), + const_cast(kwlist), /*OO*/ &type, &(pData->fget), /*OOO*/ &(pData->fset), &(pData->freset), &(pData->fdel), /*s*/ &doc, @@ -208,7 +208,7 @@ int qpropertyTpInit(PyObject* self, PyObject* args, PyObject* kwds) return -1; } -void qpropertyDeAlloc(PyObject* self) +void qpropertyDeAlloc(PyObject *self) { qpropertyClear(self); Py_TYPE(self)->tp_free(self); @@ -218,8 +218,8 @@ PyObject *qPropertyCall(PyObject *self, PyObject *args, PyObject * /* kw */) { PyObject *callback = PyTuple_GetItem(args, 0); if (PyFunction_Check(callback)) { - PySideProperty *prop = reinterpret_cast(self); - PySidePropertyPrivate* pData = prop->d; + auto prop = reinterpret_cast(self); + PySidePropertyPrivate *pData = prop->d; Py_INCREF(callback); pData->fget = callback; @@ -231,11 +231,11 @@ PyObject *qPropertyCall(PyObject *self, PyObject *args, PyObject * /* kw */) return nullptr; } -PyObject* qPropertySetter(PyObject* self, PyObject* callback) +PyObject *qPropertySetter(PyObject *self, PyObject *callback) { if (PyFunction_Check(callback)) { - PySideProperty *prop = reinterpret_cast(self); - PySidePropertyPrivate* pData = prop->d; + PySideProperty *prop = reinterpret_cast(self); + PySidePropertyPrivate *pData = prop->d; Py_INCREF(callback); pData->fset = callback; @@ -247,11 +247,11 @@ PyObject* qPropertySetter(PyObject* self, PyObject* callback) return nullptr; } -PyObject* qPropertyGetter(PyObject* self, PyObject* callback) +PyObject *qPropertyGetter(PyObject *self, PyObject *callback) { if (PyFunction_Check(callback)) { - PySideProperty *prop = reinterpret_cast(self); - PySidePropertyPrivate* pData = prop->d; + PySideProperty *prop = reinterpret_cast(self); + PySidePropertyPrivate *pData = prop->d; Py_INCREF(callback); pData->fget = callback; @@ -263,9 +263,9 @@ PyObject* qPropertyGetter(PyObject* self, PyObject* callback) return nullptr; } -static int qpropertyTraverse(PyObject* self, visitproc visit, void* arg) +static int qpropertyTraverse(PyObject *self, visitproc visit, void *arg) { - PySidePropertyPrivate* data = reinterpret_cast(self)->d; + PySidePropertyPrivate *data = reinterpret_cast(self)->d; if (!data) return 0; @@ -277,9 +277,9 @@ static int qpropertyTraverse(PyObject* self, visitproc visit, void* arg) return 0; } -static int qpropertyClear(PyObject* self) +static int qpropertyClear(PyObject *self) { - PySidePropertyPrivate* data = reinterpret_cast(self)->d; + PySidePropertyPrivate *data = reinterpret_cast(self)->d; if (!data) return 0; @@ -291,7 +291,7 @@ static int qpropertyClear(PyObject* self) delete data; - reinterpret_cast(self)->d = 0; + reinterpret_cast(self)->d = nullptr; return 0; } @@ -299,16 +299,16 @@ static int qpropertyClear(PyObject* self) namespace { -static PyObject* getFromType(PyTypeObject* type, PyObject* name) +static PyObject *getFromType(PyTypeObject *type, PyObject *name) { - PyObject* attr = 0; + PyObject *attr = nullptr; attr = PyDict_GetItem(type->tp_dict, name); if (!attr) { - PyObject* bases = type->tp_bases; + PyObject *bases = type->tp_bases; int size = PyTuple_GET_SIZE(bases); for(int i=0; i < size; i++) { - PyObject* base = PyTuple_GET_ITEM(bases, i); - attr = getFromType(reinterpret_cast(base), name); + PyObject *base = PyTuple_GET_ITEM(bases, i); + attr = getFromType(reinterpret_cast(base), name); if (attr) return attr; } @@ -321,7 +321,7 @@ static PyObject* getFromType(PyTypeObject* type, PyObject* name) namespace PySide { namespace Property { -void init(PyObject* module) +void init(PyObject *module) { if (PyType_Ready(PySidePropertyTypeF()) < 0) return; @@ -330,7 +330,7 @@ void init(PyObject* module) PyModule_AddObject(module, QPROPERTY_CLASS_NAME, reinterpret_cast(PySidePropertyTypeF())); } -bool checkType(PyObject* pyObj) +bool checkType(PyObject *pyObj) { if (pyObj) { return PyType_IsSubtype(Py_TYPE(pyObj), PySidePropertyTypeF()); @@ -338,14 +338,14 @@ bool checkType(PyObject* pyObj) return false; } -bool isPropertyType(PyObject* pyObj) +bool isPropertyType(PyObject *pyObj) { return checkType(pyObj); } -int setValue(PySideProperty* self, PyObject* source, PyObject* value) +int setValue(PySideProperty *self, PyObject *source, PyObject *value) { - PyObject* fset = self->d->fset; + PyObject *fset = self->d->fset; if (fset) { Shiboken::AutoDecRef args(PyTuple_New(2)); PyTuple_SET_ITEM(args, 0, source); @@ -360,9 +360,9 @@ int setValue(PySideProperty* self, PyObject* source, PyObject* value) return -1; } -PyObject* getValue(PySideProperty* self, PyObject* source) +PyObject *getValue(PySideProperty *self, PyObject *source) { - PyObject* fget = self->d->fget; + PyObject *fget = self->d->fget; if (fget) { Shiboken::AutoDecRef args(PyTuple_New(1)); Py_INCREF(source); @@ -372,9 +372,9 @@ PyObject* getValue(PySideProperty* self, PyObject* source) return 0; } -int reset(PySideProperty* self, PyObject* source) +int reset(PySideProperty *self, PyObject *source) { - PyObject* freset = self->d->freset; + PyObject *freset = self->d->freset; if (freset) { Shiboken::AutoDecRef args(PyTuple_New(1)); Py_INCREF(source); @@ -385,25 +385,24 @@ int reset(PySideProperty* self, PyObject* source) return -1; } -const char* getTypeName(const PySideProperty* self) +const char *getTypeName(const PySideProperty *self) { return self->d->typeName; } -PySideProperty* getObject(PyObject* source, PyObject* name) +PySideProperty *getObject(PyObject *source, PyObject *name) { - PyObject* attr = 0; + PyObject *attr = nullptr; if (Shiboken::Object::isUserType(source)) { - PyObject* dict = reinterpret_cast(source)->ob_dict; - if (dict) + if (auto dict = reinterpret_cast(source)->ob_dict) attr = PyDict_GetItem(dict, name); } attr = getFromType(Py_TYPE(source), name); if (attr && checkType(attr)) { Py_INCREF(attr); - return reinterpret_cast(attr); + return reinterpret_cast(attr); } if (!attr) @@ -417,50 +416,50 @@ bool isReadable(const PySideProperty * /* self */) return true; } -bool isWritable(const PySideProperty* self) +bool isWritable(const PySideProperty *self) { return (self->d->fset != 0); } -bool hasReset(const PySideProperty* self) +bool hasReset(const PySideProperty *self) { return (self->d->freset != 0); } -bool isDesignable(const PySideProperty* self) +bool isDesignable(const PySideProperty *self) { return self->d->designable; } -bool isScriptable(const PySideProperty* self) +bool isScriptable(const PySideProperty *self) { return self->d->scriptable; } -bool isStored(const PySideProperty* self) +bool isStored(const PySideProperty *self) { return self->d->stored; } -bool isUser(const PySideProperty* self) +bool isUser(const PySideProperty *self) { return self->d->user; } -bool isConstant(const PySideProperty* self) +bool isConstant(const PySideProperty *self) { return self->d->constant; } -bool isFinal(const PySideProperty* self) +bool isFinal(const PySideProperty *self) { return self->d->final; } -const char* getNotifyName(PySideProperty* self) +const char *getNotifyName(PySideProperty *self) { if (self->d->notifySignature.isEmpty()) { - PyObject* str = PyObject_Str(self->d->notify); + PyObject *str = PyObject_Str(self->d->notify); self->d->notifySignature = Shiboken::String::toCString(str); Py_DECREF(str); } @@ -469,22 +468,22 @@ const char* getNotifyName(PySideProperty* self) ? nullptr : self->d->notifySignature.constData(); } -void setMetaCallHandler(PySideProperty* self, MetaCallHandler handler) +void setMetaCallHandler(PySideProperty *self, MetaCallHandler handler) { self->d->metaCallHandler = handler; } -void setTypeName(PySideProperty* self, const char* typeName) +void setTypeName(PySideProperty *self, const char *typeName) { self->d->typeName = typeName; } -void setUserData(PySideProperty* self, void* data) +void setUserData(PySideProperty *self, void *data) { self->d->userData = data; } -void* userData(PySideProperty* self) +void *userData(PySideProperty *self) { return self->d->userData; } diff --git a/sources/pyside2/libpyside/pysideqflags.cpp b/sources/pyside2/libpyside/pysideqflags.cpp index cb57031b0..fd0ed005f 100644 --- a/sources/pyside2/libpyside/pysideqflags.cpp +++ b/sources/pyside2/libpyside/pysideqflags.cpp @@ -47,8 +47,8 @@ extern "C" { struct PySideQFlagsTypePrivate { - SbkConverter** converterPtr; - SbkConverter* converter; + SbkConverter **converterPtr; + SbkConverter *converter; }; /** * Type of all QFlags @@ -58,13 +58,13 @@ extern "C" { PyTypeObject type; }; - #define PYSIDE_QFLAGS(X) reinterpret_cast(X) + #define PYSIDE_QFLAGS(X) reinterpret_cast(X) PyObject *PySideQFlagsNew(PyTypeObject *type, PyObject *args, PyObject * /* kwds */) { long val = 0; if (PyTuple_GET_SIZE(args)) { - PyObject* arg = PyTuple_GET_ITEM(args, 0); + PyObject *arg = PyTuple_GET_ITEM(args, 0); if (Shiboken::isShibokenEnum(arg)) {// faster call val = Shiboken::Enum::getValue(arg); } else if (PyNumber_Check(arg)) { @@ -75,18 +75,18 @@ extern "C" { return 0; } } - PySideQFlagsObject* self = PyObject_New(PySideQFlagsObject, type); + PySideQFlagsObject *self = PyObject_New(PySideQFlagsObject, type); self->ob_value = val; - return reinterpret_cast(self); + return reinterpret_cast(self); } - static long getNumberValue(PyObject* v) + static long getNumberValue(PyObject *v) { Shiboken::AutoDecRef number(PyNumber_Long(v)); return PyLong_AsLong(number); } - PyObject* PySideQFlagsRichCompare(PyObject* self, PyObject* other, int op) + PyObject *PySideQFlagsRichCompare(PyObject *self, PyObject *other, int op) { int result = 0; if (!PyNumber_Check(other)) { @@ -163,7 +163,7 @@ namespace QFlags SbkNewQFlagsType_slots, }; - PyTypeObject *create(const char* name, PyType_Slot numberMethods[]) + PyTypeObject *create(const char *name, PyType_Slot numberMethods[]) { char qualname[200]; // PYSIDE-747: Here we insert now the full class name. @@ -183,7 +183,7 @@ namespace QFlags PyTypeObject *type = (PyTypeObject *)PyType_FromSpec(newspec); Py_TYPE(type) = &PyType_Type; - PySideQFlagsType* flagsType = reinterpret_cast(type); + PySideQFlagsType *flagsType = reinterpret_cast(type); PepType_PFTP(flagsType)->converterPtr = &PepType_PFTP(flagsType)->converter; if (PyType_Ready(type) < 0) @@ -192,14 +192,14 @@ namespace QFlags return type; } - PySideQFlagsObject* newObject(long value, PyTypeObject* type) + PySideQFlagsObject *newObject(long value, PyTypeObject *type) { - PySideQFlagsObject* qflags = PyObject_New(PySideQFlagsObject, type); + PySideQFlagsObject *qflags = PyObject_New(PySideQFlagsObject, type); qflags->ob_value = value; return qflags; } - long getValue(PySideQFlagsObject* self) + long getValue(PySideQFlagsObject *self) { return self->ob_value; } diff --git a/sources/pyside2/libpyside/pysidesignal.cpp b/sources/pyside2/libpyside/pysidesignal.cpp index 0f1993e79..169028f0c 100644 --- a/sources/pyside2/libpyside/pysidesignal.cpp +++ b/sources/pyside2/libpyside/pysidesignal.cpp @@ -71,11 +71,11 @@ namespace Signal { QMetaMethod::Attributes m_attributes = QMetaMethod::Compatibility; }; - static QByteArray buildSignature(const QByteArray &, const QByteArray &); - static void appendSignature(PySideSignal*, const SignalSignature &); - static void instanceInitialize(PySideSignalInstance*, PyObject*, PySideSignal*, PyObject*, int); - static QByteArray parseSignature(PyObject *); - static PyObject* buildQtCompatible(const QByteArray &); + static QByteArray buildSignature(const QByteArray &, const QByteArray &); + static void appendSignature(PySideSignal *, const SignalSignature &); + static void instanceInitialize(PySideSignalInstance *, PyObject *, PySideSignal *, PyObject *, int); + static QByteArray parseSignature(PyObject *); + static PyObject *buildQtCompatible(const QByteArray &); } } @@ -83,22 +83,22 @@ extern "C" { // Signal methods -static int signalTpInit(PyObject*, PyObject*, PyObject*); -static void signalFree(void*); -static void signalInstanceFree(void*); -static PyObject* signalGetItem(PyObject* self, PyObject* key); -static PyObject* signalToString(PyObject* self); +static int signalTpInit(PyObject *, PyObject *, PyObject *); +static void signalFree(void *); +static void signalInstanceFree(void *); +static PyObject *signalGetItem(PyObject *self, PyObject *key); +static PyObject *signalToString(PyObject *self); // Signal Instance methods -static PyObject* signalInstanceConnect(PyObject*, PyObject*, PyObject*); -static PyObject* signalInstanceDisconnect(PyObject*, PyObject*); -static PyObject* signalInstanceEmit(PyObject*, PyObject*); -static PyObject* signalInstanceGetItem(PyObject*, PyObject*); +static PyObject *signalInstanceConnect(PyObject *, PyObject *, PyObject *); +static PyObject *signalInstanceDisconnect(PyObject *, PyObject *); +static PyObject *signalInstanceEmit(PyObject *, PyObject *); +static PyObject *signalInstanceGetItem(PyObject *, PyObject *); -static PyObject* signalInstanceCall(PyObject* self, PyObject* args, PyObject* kw); -static PyObject* signalCall(PyObject*, PyObject*, PyObject*); +static PyObject *signalInstanceCall(PyObject *self, PyObject *args, PyObject *kw); +static PyObject *signalCall(PyObject *, PyObject *, PyObject *); -static PyObject* metaSignalCheck(PyObject*, PyObject*); +static PyObject *metaSignalCheck(PyObject *, PyObject *); static PyMethodDef Signal_methods[] = { @@ -200,28 +200,28 @@ PyTypeObject *PySideSignalInstanceTypeF(void) return type; } -int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds) +int signalTpInit(PyObject *self, PyObject *args, PyObject *kwds) { - static PyObject* emptyTuple = 0; - static const char* kwlist[] = {"name", 0}; - char* argName = 0; + static PyObject *emptyTuple = nullptr; + static const char *kwlist[] = {"name", nullptr}; + char *argName = nullptr; if (emptyTuple == 0) emptyTuple = PyTuple_New(0); if (!PyArg_ParseTupleAndKeywords(emptyTuple, kwds, - "|s:QtCore." SIGNAL_CLASS_NAME, const_cast(kwlist), &argName)) + "|s:QtCore." SIGNAL_CLASS_NAME, const_cast(kwlist), &argName)) return 0; bool tupledArgs = false; - PySideSignal* data = reinterpret_cast(self); + PySideSignal *data = reinterpret_cast(self); if (!data->data) data->data = new PySideSignalData; if (argName) data->data->signalName = argName; for (Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) { - PyObject* arg = PyTuple_GET_ITEM(args, i); + PyObject *arg = PyTuple_GET_ITEM(args, i); if (PySequence_Check(arg) && !Shiboken::String::check(arg)) { tupledArgs = true; const auto sig = PySide::Signal::parseSignature(arg); @@ -241,10 +241,10 @@ int signalTpInit(PyObject* self, PyObject* args, PyObject* kwds) return 1; } -void signalFree(void* self) +void signalFree(void *self) { - PyObject* pySelf = reinterpret_cast(self); - PySideSignal* data = reinterpret_cast(self); + auto pySelf = reinterpret_cast(self); + auto data = reinterpret_cast(self); delete data->data; data->data = nullptr; Py_XDECREF(data->homonymousMethod); @@ -253,9 +253,9 @@ void signalFree(void* self) Py_TYPE(pySelf)->tp_base->tp_free(self); } -PyObject* signalGetItem(PyObject* self, PyObject* key) +PyObject *signalGetItem(PyObject *self, PyObject *key) { - PySideSignal* data = reinterpret_cast(self); + auto data = reinterpret_cast(self); QByteArray sigKey; if (key) { sigKey = PySide::Signal::parseSignature(key); @@ -268,17 +268,17 @@ PyObject* signalGetItem(PyObject* self, PyObject* key) } -PyObject* signalToString(PyObject* self) +PyObject *signalToString(PyObject *self) { return signalGetItem(self, 0); } -void signalInstanceFree(void* self) +void signalInstanceFree(void *self) { - PyObject* pySelf = reinterpret_cast(self); - PySideSignalInstance* data = reinterpret_cast(self); + auto pySelf = reinterpret_cast(self); + auto data = reinterpret_cast(self); - PySideSignalInstancePrivate* dataPvt = data->d; + PySideSignalInstancePrivate *dataPvt = data->d; Py_XDECREF(dataPvt->homonymousMethod); @@ -291,27 +291,27 @@ void signalInstanceFree(void* self) Py_TYPE(pySelf)->tp_base->tp_free(self); } -PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds) +PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject *kwds) { - PyObject* slot = 0; - PyObject* type = 0; - static const char* kwlist[] = {"slot", "type", 0}; + PyObject *slot = nullptr; + PyObject *type = nullptr; + static const char *kwlist[] = {"slot", "type", nullptr}; if (!PyArg_ParseTupleAndKeywords(args, kwds, - "O|O:" SIGNAL_INSTANCE_NAME, const_cast(kwlist), &slot, &type)) + "O|O:" SIGNAL_INSTANCE_NAME, const_cast(kwlist), &slot, &type)) return 0; - PySideSignalInstance* source = reinterpret_cast(self); + PySideSignalInstance *source = reinterpret_cast(self); Shiboken::AutoDecRef pyArgs(PyList_New(0)); bool match = false; if (Py_TYPE(slot) == PySideSignalInstanceTypeF()) { - PySideSignalInstance* sourceWalk = source; - PySideSignalInstance* targetWalk; + PySideSignalInstance *sourceWalk = source; + PySideSignalInstance *targetWalk; //find best match while (sourceWalk && !match) { - targetWalk = reinterpret_cast(slot); + targetWalk = reinterpret_cast(slot); while (targetWalk && !match) { if (QMetaObject::checkConnectArgs(sourceWalk->d->signature, targetWalk->d->signature)) { PyList_Append(pyArgs, sourceWalk->d->source); @@ -324,9 +324,9 @@ PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds) match = true; } - targetWalk = reinterpret_cast(targetWalk->d->next); + targetWalk = reinterpret_cast(targetWalk->d->next); } - sourceWalk = reinterpret_cast(sourceWalk->d->next); + sourceWalk = reinterpret_cast(sourceWalk->d->next); } } else { // Check signature of the slot (method or function) to match signal @@ -399,7 +399,7 @@ PyObject* signalInstanceConnect(PyObject* self, PyObject* args, PyObject* kwds) PyErr_SetString(PyExc_RuntimeError, "method 'connect' vanished!"); return 0; } - PyObject* result = PyObject_CallObject(pyMethod, tupleArgs); + PyObject *result = PyObject_CallObject(pyMethod, tupleArgs); if (result == Py_True || result == Py_False) return result; Py_XDECREF(result); @@ -415,9 +415,9 @@ int argCountInSignature(const char *signature) return QByteArray(signature).count(",") + 1; } -PyObject* signalInstanceEmit(PyObject* self, PyObject* args) +PyObject *signalInstanceEmit(PyObject *self, PyObject *args) { - PySideSignalInstance* source = reinterpret_cast(self); + PySideSignalInstance *source = reinterpret_cast(self); Shiboken::AutoDecRef pyArgs(PyList_New(0)); int numArgsGiven = PySequence_Fast_GET_SIZE(args); @@ -453,15 +453,15 @@ PyObject* signalInstanceEmit(PyObject* self, PyObject* args) return PyObject_CallObject(pyMethod, tupleArgs); } -PyObject* signalInstanceGetItem(PyObject* self, PyObject* key) +PyObject *signalInstanceGetItem(PyObject *self, PyObject *key) { - PySideSignalInstance* data = reinterpret_cast(self); + auto data = reinterpret_cast(self); const auto sigName = data->d->signalName; const auto sigKey = PySide::Signal::parseSignature(key); const auto sig = PySide::Signal::buildSignature(sigName, sigKey); while (data) { if (data->d->signature == sig) { - PyObject* result = reinterpret_cast(data); + PyObject *result = reinterpret_cast(data); Py_INCREF(result); return result; } @@ -473,12 +473,12 @@ PyObject* signalInstanceGetItem(PyObject* self, PyObject* key) return 0; } -PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args) +PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args) { - PySideSignalInstance* source = reinterpret_cast(self); + auto source = reinterpret_cast(self); Shiboken::AutoDecRef pyArgs(PyList_New(0)); - PyObject* slot; + PyObject *slot; if (PyTuple_Check(args) && PyTuple_GET_SIZE(args)) slot = PyTuple_GET_ITEM(args, 0); else @@ -486,7 +486,7 @@ PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args) bool match = false; if (Py_TYPE(slot) == PySideSignalInstanceTypeF()) { - PySideSignalInstance* target = reinterpret_cast(slot); + PySideSignalInstance *target = reinterpret_cast(slot); if (QMetaObject::checkConnectArgs(source->d->signature, target->d->signature)) { PyList_Append(pyArgs, source->d->source); Shiboken::AutoDecRef source_signature(PySide::Signal::buildQtCompatible(source->d->signature)); @@ -513,7 +513,7 @@ PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args) if (match) { Shiboken::AutoDecRef tupleArgs(PyList_AsTuple(pyArgs)); Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(source->d->source, "disconnect")); - PyObject* result = PyObject_CallObject(pyMethod, tupleArgs); + PyObject *result = PyObject_CallObject(pyMethod, tupleArgs); if (!result || result == Py_True) return result; else @@ -525,9 +525,9 @@ PyObject* signalInstanceDisconnect(PyObject* self, PyObject* args) return 0; } -PyObject* signalCall(PyObject* self, PyObject* args, PyObject* kw) +PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw) { - PySideSignal* signal = reinterpret_cast(self); + auto signal = reinterpret_cast(self); // Native C++ signals can't be called like functions, thus we throw an exception. // The only way calling a signal can succeed (the Python equivalent of C++'s operator() ) @@ -553,9 +553,9 @@ PyObject* signalCall(PyObject* self, PyObject* args, PyObject* kw) return callFunc(homonymousMethod, args, kw); } -PyObject* signalInstanceCall(PyObject* self, PyObject* args, PyObject* kw) +PyObject *signalInstanceCall(PyObject *self, PyObject *args, PyObject *kw) { - PySideSignalInstance* PySideSignal = reinterpret_cast(self); + auto PySideSignal = reinterpret_cast(self); if (!PySideSignal->d->homonymousMethod) { PyErr_SetString(PyExc_TypeError, "native Qt signal is not callable"); return 0; @@ -566,7 +566,7 @@ PyObject* signalInstanceCall(PyObject* self, PyObject* args, PyObject* kw) return PyCFunction_Call(homonymousMethod, args, kw); } -static PyObject *metaSignalCheck(PyObject * /* klass */, PyObject* args) +static PyObject *metaSignalCheck(PyObject * /* klass */, PyObject *args) { if (PyType_IsSubtype(Py_TYPE(args), PySideSignalInstanceTypeF())) Py_RETURN_TRUE; @@ -579,7 +579,7 @@ static PyObject *metaSignalCheck(PyObject * /* klass */, PyObject* args) namespace PySide { namespace Signal { -void init(PyObject* module) +void init(PyObject *module) { if (PyType_Ready(PySideSignalMetaTypeF()) < 0) return; @@ -596,25 +596,25 @@ void init(PyObject* module) Py_INCREF(PySideSignalInstanceTypeF()); } -bool checkType(PyObject* pyObj) +bool checkType(PyObject *pyObj) { if (pyObj) return PyType_IsSubtype(Py_TYPE(pyObj), PySideSignalTypeF()); return false; } -void updateSourceObject(PyObject* source) +void updateSourceObject(PyObject *source) { - PyTypeObject* objType = reinterpret_cast(PyObject_Type(source)); + PyTypeObject *objType = reinterpret_cast(PyObject_Type(source)); Py_ssize_t pos = 0; - PyObject* value; - PyObject* key; + PyObject *value; + PyObject *key; while (PyDict_Next(objType->tp_dict, &pos, &key, &value)) { if (PyObject_TypeCheck(value, PySideSignalTypeF())) { Shiboken::AutoDecRef signalInstance(reinterpret_cast(PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF()))); - instanceInitialize(signalInstance.cast(), key, reinterpret_cast(value), source, 0); + instanceInitialize(signalInstance.cast(), key, reinterpret_cast(value), source, 0); PyObject_SetAttr(source, key, signalInstance); } } @@ -625,13 +625,13 @@ void updateSourceObject(PyObject* source) QByteArray getTypeName(PyObject *type) { if (PyType_Check(type)) { - if (PyType_IsSubtype(reinterpret_cast(type), - reinterpret_cast(SbkObject_TypeF()))) { - SbkObjectType* objType = reinterpret_cast(type); + if (PyType_IsSubtype(reinterpret_cast(type), + reinterpret_cast(SbkObject_TypeF()))) { + auto objType = reinterpret_cast(type); return Shiboken::ObjectType::getOriginalName(objType); } // Translate python types to Qt names - PyTypeObject* objType = reinterpret_cast(type); + auto objType = reinterpret_cast(type); if (Shiboken::String::checkType(objType)) return QByteArrayLiteral("QString"); if (objType == &PyInt_Type) @@ -662,7 +662,7 @@ QByteArray buildSignature(const QByteArray &name, const QByteArray &signature) return QMetaObject::normalizedSignature(name + '(' + signature + ')'); } -QByteArray parseSignature(PyObject* args) +QByteArray parseSignature(PyObject *args) { if (args && (Shiboken::String::check(args) || !PySequence_Check(args))) return getTypeName(args); @@ -680,25 +680,25 @@ QByteArray parseSignature(PyObject* args) return signature; } -void appendSignature(PySideSignal* self, const SignalSignature &signature) +void appendSignature(PySideSignal *self, const SignalSignature &signature) { self->data->signatures.append({signature.m_parameterTypes, signature.m_attributes}); } -PySideSignalInstance* initialize(PySideSignal* self, PyObject* name, PyObject* object) +PySideSignalInstance *initialize(PySideSignal *self, PyObject *name, PyObject *object) { - PySideSignalInstance* instance = PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF()); - SbkObject* sbkObj = reinterpret_cast(object); + PySideSignalInstance *instance = PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF()); + auto sbkObj = reinterpret_cast(object); if (!Shiboken::Object::wasCreatedByPython(sbkObj)) Py_INCREF(object); // PYSIDE-79: this flag was crucial for a wrapper call. instanceInitialize(instance, name, self, object, 0); return instance; } -void instanceInitialize(PySideSignalInstance* self, PyObject* name, PySideSignal* data, PyObject* source, int index) +void instanceInitialize(PySideSignalInstance *self, PyObject *name, PySideSignal *data, PyObject *source, int index) { self->d = new PySideSignalInstancePrivate; - PySideSignalInstancePrivate* selfPvt = self->d; + PySideSignalInstancePrivate *selfPvt = self->d; selfPvt->next = nullptr; if (data->data->signalName.isEmpty()) data->data->signalName = Shiboken::String::toCString(name); @@ -721,7 +721,7 @@ void instanceInitialize(PySideSignalInstance* self, PyObject* name, PySideSignal } } -bool connect(PyObject* source, const char* signal, PyObject* callback) +bool connect(PyObject *source, const char *signal, PyObject *callback) { Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(source, "connect")); if (pyMethod.isNull()) @@ -729,7 +729,7 @@ bool connect(PyObject* source, const char* signal, PyObject* callback) Shiboken::AutoDecRef pySignature(Shiboken::String::fromCString(signal)); Shiboken::AutoDecRef pyArgs(PyTuple_Pack(3, source, pySignature.object(), callback)); - PyObject* result = PyObject_CallObject(pyMethod, pyArgs); + PyObject *result = PyObject_CallObject(pyMethod, pyArgs); if (result == Py_False) { PyErr_Format(PyExc_RuntimeError, "Failed to connect signal %s, to python callable object.", signal); Py_DECREF(result); @@ -738,12 +738,12 @@ bool connect(PyObject* source, const char* signal, PyObject* callback) return result; } -PySideSignalInstance* newObjectFromMethod(PyObject* source, const QList& methodList) +PySideSignalInstance *newObjectFromMethod(PyObject *source, const QList& methodList) { - PySideSignalInstance* root = 0; - PySideSignalInstance* previous = 0; + PySideSignalInstance *root = nullptr; + PySideSignalInstance *previous = nullptr; for (const QMetaMethod &m : methodList) { - PySideSignalInstance* item = PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF()); + PySideSignalInstance *item = PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF()); if (!root) root = item; @@ -751,7 +751,7 @@ PySideSignalInstance* newObjectFromMethod(PyObject* source, const QListd->next = item; item->d = new PySideSignalInstancePrivate; - PySideSignalInstancePrivate* selfPvt = item->d; + PySideSignalInstancePrivate *selfPvt = item->d; selfPvt->source = source; Py_INCREF(selfPvt->source); // PYSIDE-79: an INCREF is missing. QByteArray cppName(m.methodSignature()); @@ -766,17 +766,17 @@ PySideSignalInstance* newObjectFromMethod(PyObject* source, const QListdata = new PySideSignalData; self->data->signalName = name; self->homonymousMethod = 0; va_start(listSignatures, name); - sig = va_arg(listSignatures, char*); + sig = va_arg(listSignatures, char *); while (sig != NULL) { if (strcmp(sig, "void") == 0) @@ -784,7 +784,7 @@ PySideSignal* newObject(const char* name, ...) else appendSignature(self, SignalSignature(sig)); - sig = va_arg(listSignatures, char*); + sig = va_arg(listSignatures, char *); } va_end(listSignatures); @@ -793,7 +793,7 @@ PySideSignal* newObject(const char* name, ...) } template -static typename T::value_type join(T t, const char* sep) +static typename T::value_type join(T t, const char *sep) { typename T::value_type res; if (t.isEmpty()) @@ -812,15 +812,15 @@ static typename T::value_type join(T t, const char* sep) return res; } -static void _addSignalToWrapper(SbkObjectType* wrapperType, const char* signalName, PySideSignal* signal) +static void _addSignalToWrapper(SbkObjectType *wrapperType, const char *signalName, PySideSignal *signal) { - PyObject* typeDict = reinterpret_cast(wrapperType)->tp_dict; - PyObject* homonymousMethod; + auto typeDict = reinterpret_cast(wrapperType)->tp_dict; + PyObject *homonymousMethod; if ((homonymousMethod = PyDict_GetItemString(typeDict, signalName))) { Py_INCREF(homonymousMethod); signal->homonymousMethod = homonymousMethod; } - PyDict_SetItemString(typeDict, signalName, reinterpret_cast(signal)); + PyDict_SetItemString(typeDict, signalName, reinterpret_cast(signal)); } // This function is used by qStableSort to promote empty signatures @@ -829,7 +829,7 @@ static bool compareSignals(const SignalSignature &sig1, const SignalSignature &) return sig1.m_parameterTypes.isEmpty(); } -void registerSignals(SbkObjectType* pyObj, const QMetaObject* metaObject) +void registerSignals(SbkObjectType *pyObj, const QMetaObject *metaObject) { typedef QHash > SignalSigMap; SignalSigMap signalsFound; @@ -850,7 +850,7 @@ void registerSignals(SbkObjectType* pyObj, const QMetaObject* metaObject) SignalSigMap::Iterator it = signalsFound.begin(); SignalSigMap::Iterator end = signalsFound.end(); for (; it != end; ++it) { - PySideSignal* self = PyObject_New(PySideSignal, PySideSignalTypeF()); + PySideSignal *self = PyObject_New(PySideSignal, PySideSignalTypeF()); self->data = new PySideSignalData; self->data->signalName = it.key(); self->homonymousMethod = 0; @@ -869,28 +869,28 @@ void registerSignals(SbkObjectType* pyObj, const QMetaObject* metaObject) } } -PyObject* buildQtCompatible(const QByteArray &signature) +PyObject *buildQtCompatible(const QByteArray &signature) { const auto ba = QT_SIGNAL_SENTINEL + signature; return Shiboken::String::fromStringAndSize(ba, ba.size()); } -void addSignalToWrapper(SbkObjectType* wrapperType, const char* signalName, PySideSignal* signal) +void addSignalToWrapper(SbkObjectType *wrapperType, const char *signalName, PySideSignal *signal) { _addSignalToWrapper(wrapperType, signalName, signal); } -PyObject* getObject(PySideSignalInstance* signal) +PyObject *getObject(PySideSignalInstance *signal) { return signal->d->source; } -const char* getSignature(PySideSignalInstance* signal) +const char *getSignature(PySideSignalInstance *signal) { return signal->d->signature; } -QStringList getArgsFromSignature(const char* signature, bool* isShortCircuit) +QStringList getArgsFromSignature(const char *signature, bool *isShortCircuit) { const QString qsignature = QLatin1String(signature); QStringList result; @@ -910,7 +910,7 @@ QStringList getArgsFromSignature(const char* signature, bool* isShortCircuit) return result; } -QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* callback, bool encodeName) +QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *callback, bool encodeName) { QByteArray functionName; int numArgs = -1; @@ -919,8 +919,8 @@ QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* ca bool isFunction = PyFunction_Check(callback); if (isMethod || isFunction) { - PyObject* function = isMethod ? PyMethod_GET_FUNCTION(callback) : callback; - PyCodeObject* objCode = reinterpret_cast(PyFunction_GET_CODE(function)); + PyObject *function = isMethod ? PyMethod_GET_FUNCTION(callback) : callback; + auto objCode = reinterpret_cast(PyFunction_GET_CODE(function)); functionName = Shiboken::String::toCString(PepFunction_GetName(function)); useSelf = isMethod; numArgs = PepCode_GET_FLAGS(objCode) & CO_VARARGS ? -1 : PepCode_GET_ARGCOUNT(objCode); @@ -932,7 +932,7 @@ QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* ca if (receiver) { //Search for signature on metaobject - const QMetaObject* mo = receiver->metaObject(); + const QMetaObject *mo = receiver->metaObject(); QByteArray prefix(functionName); prefix += '('; for (int i = 0; i < mo->methodCount(); i++) { @@ -976,12 +976,12 @@ QString getCallbackSignature(const char* signal, QObject* receiver, PyObject* ca return signature; } -bool isQtSignal(const char* signal) +bool isQtSignal(const char *signal) { return (signal && signal[0] == QT_SIGNAL_SENTINEL); } -bool checkQtSignal(const char* signal) +bool checkQtSignal(const char *signal) { if (!isQtSignal(signal)) { PyErr_SetString(PyExc_TypeError, "Use the function PySide2.QtCore.SIGNAL on signals"); @@ -990,11 +990,11 @@ bool checkQtSignal(const char* signal) return true; } -QString codeCallbackName(PyObject* callback, const QString& funcName) +QString codeCallbackName(PyObject *callback, const QString &funcName) { if (PyMethod_Check(callback)) { - PyObject* self = PyMethod_GET_SELF(callback); - PyObject* func = PyMethod_GET_FUNCTION(callback); + PyObject *self = PyMethod_GET_SELF(callback); + PyObject *func = PyMethod_GET_FUNCTION(callback); return funcName + QString::number(quint64(self), 16) + QString::number(quint64(func), 16); } return funcName + QString::number(quint64(callback), 16); diff --git a/sources/pyside2/libpyside/pysideslot.cpp b/sources/pyside2/libpyside/pysideslot.cpp index 4104c090d..2cdf32626 100644 --- a/sources/pyside2/libpyside/pysideslot.cpp +++ b/sources/pyside2/libpyside/pysideslot.cpp @@ -64,8 +64,8 @@ typedef struct extern "C" { -static int slotTpInit(PyObject*, PyObject*, PyObject*); -static PyObject* slotCall(PyObject*, PyObject*, PyObject*); +static int slotTpInit(PyObject *, PyObject *, PyObject *); +static PyObject *slotCall(PyObject *, PyObject *, PyObject *); // Class Definition ----------------------------------------------- static PyType_Slot PySideSlotType_slots[] = { @@ -94,20 +94,20 @@ static PyTypeObject *PySideSlotTypeF(void) int slotTpInit(PyObject *self, PyObject *args, PyObject *kw) { - static PyObject *emptyTuple = 0; - static const char *kwlist[] = {"name", "result", 0}; - char* argName = 0; - PyObject* argResult = 0; + static PyObject *emptyTuple = nullptr; + static const char *kwlist[] = {"name", "result", nullptr}; + char *argName = nullptr; + PyObject *argResult = nullptr; if (emptyTuple == 0) emptyTuple = PyTuple_New(0); if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sO:QtCore." SLOT_DEC_NAME, - const_cast(kwlist), &argName, &argResult)) { + const_cast(kwlist), &argName, &argResult)) { return 0; } - PySideSlot *data = reinterpret_cast(self); + PySideSlot *data = reinterpret_cast(self); if (!data->slotData) data->slotData = new SlotData; for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) { @@ -133,13 +133,13 @@ int slotTpInit(PyObject *self, PyObject *args, PyObject *kw) PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */) { - static PyObject* pySlotName = 0; - PyObject* callback; + static PyObject *pySlotName = nullptr; + PyObject *callback; callback = PyTuple_GetItem(args, 0); Py_INCREF(callback); if (PyFunction_Check(callback)) { - PySideSlot *data = reinterpret_cast(self); + PySideSlot *data = reinterpret_cast(self); if (!data->slotData) data->slotData = new SlotData; @@ -179,7 +179,7 @@ PyObject *slotCall(PyObject *self, PyObject *args, PyObject * /* kw */) namespace PySide { namespace Slot { -void init(PyObject* module) +void init(PyObject *module) { if (PyType_Ready(PySideSlotTypeF()) < 0) return; diff --git a/sources/pyside2/libpyside/pysideweakref.cpp b/sources/pyside2/libpyside/pysideweakref.cpp index 6b5073db8..2b27f9545 100644 --- a/sources/pyside2/libpyside/pysideweakref.cpp +++ b/sources/pyside2/libpyside/pysideweakref.cpp @@ -46,10 +46,10 @@ typedef struct { PyObject_HEAD /* Type-specific fields go here. */ PySideWeakRefFunction weakref_func; - void* user_data; + void *user_data; } PySideCallableObject; -static PyObject* CallableObject_call(PyObject* callable_object, PyObject* args, PyObject* kw); +static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args, PyObject *kw); static PyType_Slot PySideCallableObjectType_slots[] = { {Py_tp_call, (void *)CallableObject_call}, @@ -57,7 +57,7 @@ static PyType_Slot PySideCallableObjectType_slots[] = { {0, 0} }; static PyType_Spec PySideCallableObjectType_spec = { - const_cast("PySide.Callable"), + const_cast("PySide.Callable"), sizeof(PySideCallableObject), 0, Py_TPFLAGS_DEFAULT, @@ -74,7 +74,7 @@ static PyTypeObject *PySideCallableObjectTypeF() static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args, PyObject * /* kw */) { - PySideCallableObject* obj = reinterpret_cast(callable_object); + PySideCallableObject *obj = reinterpret_cast(callable_object); obj->weakref_func(obj->user_data); Py_XDECREF(PyTuple_GET_ITEM(args, 0)); //kill weak ref object @@ -83,7 +83,7 @@ static PyObject *CallableObject_call(PyObject *callable_object, PyObject *args, namespace PySide { namespace WeakRef { -PyObject* create(PyObject* obj, PySideWeakRefFunction func, void* userData) +PyObject *create(PyObject *obj, PySideWeakRefFunction func, void *userData) { if (obj == Py_None) return 0; @@ -94,11 +94,11 @@ PyObject* create(PyObject* obj, PySideWeakRefFunction func, void* userData) PyType_Ready(PySideCallableObjectTypeF()); } - PySideCallableObject* callable = PyObject_New(PySideCallableObject, PySideCallableObjectTypeF()); + PySideCallableObject *callable = PyObject_New(PySideCallableObject, PySideCallableObjectTypeF()); if (!callable || PyErr_Occurred()) return 0; - PyObject* weak = PyWeakref_NewRef(obj, reinterpret_cast(callable)); + PyObject *weak = PyWeakref_NewRef(obj, reinterpret_cast(callable)); if (!weak || PyErr_Occurred()) return 0; diff --git a/sources/pyside2/libpyside/signalmanager.cpp b/sources/pyside2/libpyside/signalmanager.cpp index 8925ffd35..0895cc682 100644 --- a/sources/pyside2/libpyside/signalmanager.cpp +++ b/sources/pyside2/libpyside/signalmanager.cpp @@ -82,26 +82,26 @@ namespace { static PyObject *metaObjectAttr = 0; - static int callMethod(QObject* object, int id, void** args); - static PyObject* parseArguments(const QList< QByteArray >& paramTypes, void** args); - static bool emitShortCircuitSignal(QObject* source, int signalIndex, PyObject* args); + static int callMethod(QObject *object, int id, void **args); + static PyObject *parseArguments(const QList< QByteArray >& paramTypes, void **args); + static bool emitShortCircuitSignal(QObject *source, int signalIndex, PyObject *args); #ifdef IS_PY3K - static void destroyMetaObject(PyObject* obj) + static void destroyMetaObject(PyObject *obj) { - void* ptr = PyCapsule_GetPointer(obj, 0); - auto meta = reinterpret_cast(ptr); - SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta); + void *ptr = PyCapsule_GetPointer(obj, 0); + auto meta = reinterpret_cast(ptr); + SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta); if (wrapper) Shiboken::BindingManager::instance().releaseWrapper(wrapper); delete meta; } #else - static void destroyMetaObject(void* obj) + static void destroyMetaObject(void *obj) { - auto meta = reinterpret_cast(obj); - SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta); + auto meta = reinterpret_cast(obj); + SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(meta); if (wrapper) Shiboken::BindingManager::instance().releaseWrapper(wrapper); delete meta; @@ -118,7 +118,7 @@ PyObjectWrapper::PyObjectWrapper() Py_XINCREF(m_me); } -PyObjectWrapper::PyObjectWrapper(PyObject* me) +PyObjectWrapper::PyObjectWrapper(PyObject *me) : m_me(me) { Py_XINCREF(m_me); @@ -148,18 +148,18 @@ void PyObjectWrapper::reset(PyObject *o) m_me = o; } -PyObjectWrapper& PyObjectWrapper::operator=(const PySide::PyObjectWrapper& other) +PyObjectWrapper &PyObjectWrapper::operator=(const PySide::PyObjectWrapper &other) { reset(other.m_me); return *this; } -PyObjectWrapper::operator PyObject*() const +PyObjectWrapper::operator PyObject *() const { return m_me; } -QDataStream &operator<<(QDataStream& out, const PyObjectWrapper& myObj) +QDataStream &operator<<(QDataStream &out, const PyObjectWrapper &myObj) { if (Py_IsInitialized() == 0) { qWarning() << "Stream operator for PyObject called without python interpreter."; @@ -173,9 +173,9 @@ QDataStream &operator<<(QDataStream& out, const PyObjectWrapper& myObj) Shiboken::AutoDecRef pickleModule(PyImport_ImportModule("pickle")); reduce_func = PyObject_GetAttrString(pickleModule, "dumps"); } - Shiboken::AutoDecRef repr(PyObject_CallFunctionObjArgs(reduce_func, (PyObject*)myObj, NULL)); + Shiboken::AutoDecRef repr(PyObject_CallFunctionObjArgs(reduce_func, (PyObject *)myObj, NULL)); if (repr.object()) { - const char* buff = 0; + const char *buff = nullptr; Py_ssize_t size = 0; if (PyBytes_Check(repr.object())) { buff = PyBytes_AS_STRING(repr.object()); @@ -190,7 +190,7 @@ QDataStream &operator<<(QDataStream& out, const PyObjectWrapper& myObj) return out; } -QDataStream &operator>>(QDataStream& in, PyObjectWrapper& myObj) +QDataStream &operator>>(QDataStream &in, PyObjectWrapper &myObj) { if (Py_IsInitialized() == 0) { qWarning() << "Stream operator for PyObject called without python interpreter."; @@ -225,7 +225,7 @@ struct SignalManager::SignalManagerPrivate SignalManagerPrivate() { - m_globalReceivers = SharedMap( new QMap() ); + m_globalReceivers = SharedMap( new QMap() ); } ~SignalManagerPrivate() @@ -246,17 +246,17 @@ static void clearSignalManager() PySide::SignalManager::instance().clear(); } -static void PyObject_PythonToCpp_PyObject_PTR(PyObject* pyIn, void* cppOut) +static void PyObject_PythonToCpp_PyObject_PTR(PyObject *pyIn, void *cppOut) { - *((PyObject**)cppOut) = pyIn; + *reinterpret_cast(cppOut) = pyIn; } -static PythonToCppFunc is_PyObject_PythonToCpp_PyObject_PTR_Convertible(PyObject* pyIn) +static PythonToCppFunc is_PyObject_PythonToCpp_PyObject_PTR_Convertible(PyObject *pyIn) { return PyObject_PythonToCpp_PyObject_PTR; } -static PyObject* PyObject_PTR_CppToPython_PyObject(const void* cppIn) +static PyObject *PyObject_PTR_CppToPython_PyObject(const void *cppIn) { - PyObject* pyOut = (PyObject*)cppIn; + auto pyOut = reinterpret_cast(const_cast(cppIn)); if (pyOut) Py_INCREF(pyOut); return pyOut; @@ -273,7 +273,7 @@ SignalManager::SignalManager() : m_d(new SignalManagerPrivate) qRegisterMetaTypeStreamOperators("PyObjectWrapper"); qRegisterMetaTypeStreamOperators("PySide::PyObjectWrapper"); - SbkConverter* converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type, 0); + SbkConverter *converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type, nullptr); Shiboken::Conversions::setCppPointerToPythonFunction(converter, PyObject_PTR_CppToPython_PyObject); Shiboken::Conversions::setPythonToCppPointerFunctions(converter, PyObject_PythonToCpp_PyObject_PTR, is_PyObject_PythonToCpp_PyObject_PTR_Convertible); Shiboken::Conversions::registerConverterName(converter, PYTHON_TYPE); @@ -298,17 +298,17 @@ SignalManager::~SignalManager() delete m_d; } -SignalManager& SignalManager::instance() +SignalManager &SignalManager::instance() { static SignalManager me; return me; } -QObject* SignalManager::globalReceiver(QObject *sender, PyObject *callback) +QObject *SignalManager::globalReceiver(QObject *sender, PyObject *callback) { SharedMap globalReceivers = m_d->m_globalReceivers; QByteArray hash = GlobalReceiverV2::hash(callback); - GlobalReceiverV2* gr = 0; + GlobalReceiverV2 *gr = nullptr; auto it = globalReceivers->find(hash); if (it == globalReceivers->end()) { gr = new GlobalReceiverV2(callback, globalReceivers); @@ -323,7 +323,7 @@ QObject* SignalManager::globalReceiver(QObject *sender, PyObject *callback) gr->incRef(sender); } - return reinterpret_cast(gr); + return reinterpret_cast(gr); } int SignalManager::countConnectionsWith(const QObject *object) @@ -336,23 +336,23 @@ int SignalManager::countConnectionsWith(const QObject *object) return count; } -void SignalManager::notifyGlobalReceiver(QObject* receiver) +void SignalManager::notifyGlobalReceiver(QObject *receiver) { - reinterpret_cast(receiver)->notify(); + reinterpret_cast(receiver)->notify(); } -void SignalManager::releaseGlobalReceiver(const QObject* source, QObject* receiver) +void SignalManager::releaseGlobalReceiver(const QObject *source, QObject *receiver) { - GlobalReceiverV2* gr = reinterpret_cast(receiver); + auto gr = reinterpret_cast(receiver); gr->decRef(source); } -int SignalManager::globalReceiverSlotIndex(QObject* receiver, const char* signature) const +int SignalManager::globalReceiverSlotIndex(QObject *receiver, const char *signature) const { - return reinterpret_cast(receiver)->addSlot(signature); + return reinterpret_cast(receiver)->addSlot(signature); } -bool SignalManager::emitSignal(QObject* source, const char* signal, PyObject* args) +bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *args) { if (!Signal::checkQtSignal(signal)) return false; @@ -372,13 +372,13 @@ bool SignalManager::emitSignal(QObject* source, const char* signal, PyObject* ar return false; } -int SignalManager::qt_metacall(QObject* object, QMetaObject::Call call, int id, void** args) +int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id, void **args) { - const QMetaObject* metaObject = object->metaObject(); - PySideProperty* pp = 0; - PyObject* pp_name = 0; + const QMetaObject *metaObject = object->metaObject(); + PySideProperty *pp = nullptr; + PyObject *pp_name = nullptr; QMetaProperty mp; - PyObject* pySelf = 0; + PyObject *pySelf = nullptr; int methodCount = metaObject->methodCount(); int propertyCount = metaObject->propertyCount(); @@ -389,7 +389,7 @@ int SignalManager::qt_metacall(QObject* object, QMetaObject::Call call, int id, } Shiboken::GilState gil; - pySelf = (PyObject*)Shiboken::BindingManager::instance().retrieveWrapper(object); + pySelf = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(object)); Q_ASSERT(pySelf); pp_name = Shiboken::String::fromCString(mp.name()); pp = Property::getObject(pySelf, pp_name); @@ -504,22 +504,22 @@ int SignalManager::qt_metacall(QObject* object, QMetaObject::Call call, int id, return id; } -int SignalManager::callPythonMetaMethod(const QMetaMethod& method, void** args, PyObject* pyMethod, bool isShortCuit) +int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args, PyObject *pyMethod, bool isShortCuit) { Q_ASSERT(pyMethod); Shiboken::GilState gil; - PyObject* pyArguments = 0; + PyObject *pyArguments = nullptr; if (isShortCuit){ - pyArguments = reinterpret_cast(args[1]); + pyArguments = reinterpret_cast(args[1]); } else { pyArguments = parseArguments(method.parameterTypes(), args); } if (pyArguments) { - Shiboken::Conversions::SpecificConverter* retConverter = NULL; - const char* returnType = method.typeName(); + Shiboken::Conversions::SpecificConverter *retConverter = nullptr; + const char *returnType = method.typeName(); if (returnType && std::strcmp("", returnType) && std::strcmp("void", returnType)) { retConverter = new Shiboken::Conversions::SpecificConverter(returnType); if (!retConverter || !*retConverter) { @@ -543,13 +543,13 @@ int SignalManager::callPythonMetaMethod(const QMetaMethod& method, void** args, return -1; } -bool SignalManager::registerMetaMethod(QObject* source, const char* signature, QMetaMethod::MethodType type) +bool SignalManager::registerMetaMethod(QObject *source, const char *signature, QMetaMethod::MethodType type) { int ret = registerMetaMethodGetIndex(source, signature, type); return (ret != -1); } -static MetaObjectBuilder *metaBuilderFromDict(PyObject* dict) +static MetaObjectBuilder *metaBuilderFromDict(PyObject *dict) { if (!dict || !PyDict_Contains(dict, metaObjectAttr)) return nullptr; @@ -562,33 +562,33 @@ static MetaObjectBuilder *metaBuilderFromDict(PyObject* dict) #endif } -int SignalManager::registerMetaMethodGetIndex(QObject* source, const char* signature, QMetaMethod::MethodType type) +int SignalManager::registerMetaMethodGetIndex(QObject *source, const char *signature, QMetaMethod::MethodType type) { if (!source) { qWarning("SignalManager::registerMetaMethodGetIndex(\"%s\") called with source=nullptr.", signature); return -1; } - const QMetaObject* metaObject = source->metaObject(); + const QMetaObject *metaObject = source->metaObject(); int methodIndex = metaObject->indexOfMethod(signature); // Create the dynamic signal is needed if (methodIndex == -1) { - SbkObject* self = Shiboken::BindingManager::instance().retrieveWrapper(source); + SbkObject *self = Shiboken::BindingManager::instance().retrieveWrapper(source); if (!Shiboken::Object::hasCppWrapper(self)) { qWarning() << "Invalid Signal signature:" << signature; return -1; } else { - PyObject *pySelf = reinterpret_cast(self); - PyObject* dict = self->ob_dict; + auto pySelf = reinterpret_cast(self); + PyObject *dict = self->ob_dict; MetaObjectBuilder *dmo = metaBuilderFromDict(dict); // Create a instance meta object if (!dmo) { dmo = new MetaObjectBuilder(Py_TYPE(pySelf), metaObject); #ifdef IS_PY3K - PyObject* pyDmo = PyCapsule_New(dmo, 0, destroyMetaObject); + PyObject *pyDmo = PyCapsule_New(dmo, 0, destroyMetaObject); #else - PyObject* pyDmo = PyCObject_FromVoidPtr(dmo, destroyMetaObject); + PyObject *pyDmo = PyCObject_FromVoidPtr(dmo, destroyMetaObject); #endif PyObject_SetAttr(pySelf, metaObjectAttr, pyDmo); @@ -604,12 +604,12 @@ int SignalManager::registerMetaMethodGetIndex(QObject* source, const char* signa return methodIndex; } -const QMetaObject* SignalManager::retrieveMetaObject(PyObject *self) +const QMetaObject *SignalManager::retrieveMetaObject(PyObject *self) { Shiboken::GilState gil; Q_ASSERT(self); - MetaObjectBuilder *builder = metaBuilderFromDict(reinterpret_cast(self)->ob_dict); + MetaObjectBuilder *builder = metaBuilderFromDict(reinterpret_cast(self)->ob_dict); if (!builder) builder = &(retrieveTypeUserData(self)->mo); @@ -618,9 +618,9 @@ const QMetaObject* SignalManager::retrieveMetaObject(PyObject *self) namespace { -static int callMethod(QObject* object, int id, void** args) +static int callMethod(QObject *object, int id, void **args) { - const QMetaObject* metaObject = object->metaObject(); + const QMetaObject *metaObject = object->metaObject(); QMetaMethod method = metaObject->method(id); if (method.methodType() == QMetaMethod::Signal) { @@ -628,7 +628,7 @@ static int callMethod(QObject* object, int id, void** args) QMetaObject::activate(object, id, args); } else { Shiboken::GilState gil; - PyObject* self = (PyObject*)Shiboken::BindingManager::instance().retrieveWrapper(object); + auto self = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(object)); QByteArray methodName = method.methodSignature(); methodName.truncate(methodName.indexOf('(')); Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(self, methodName)); @@ -638,14 +638,14 @@ static int callMethod(QObject* object, int id, void** args) } -static PyObject* parseArguments(const QList& paramTypes, void** args) +static PyObject *parseArguments(const QList& paramTypes, void **args) { int argsSize = paramTypes.count(); - PyObject* preparedArgs = PyTuple_New(argsSize); + PyObject *preparedArgs = PyTuple_New(argsSize); for (int i = 0, max = argsSize; i < max; ++i) { - void* data = args[i+1]; - const char* dataType = paramTypes[i].constData(); + void *data = args[i+1]; + const char *dataType = paramTypes[i].constData(); Shiboken::Conversions::SpecificConverter converter(dataType); if (converter) { PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data)); @@ -658,9 +658,9 @@ static PyObject* parseArguments(const QList& paramTypes, void** args return preparedArgs; } -static bool emitShortCircuitSignal(QObject* source, int signalIndex, PyObject* args) +static bool emitShortCircuitSignal(QObject *source, int signalIndex, PyObject *args) { - void* signalArgs[2] = {0, args}; + void *signalArgs[2] = {nullptr, args}; source->qt_metacall(QMetaObject::InvokeMetaMethod, signalIndex, signalArgs); return true; } diff --git a/sources/pyside2/plugins/customwidget.cpp b/sources/pyside2/plugins/customwidget.cpp index f3ce09b62..6a6d7a3be 100644 --- a/sources/pyside2/plugins/customwidget.cpp +++ b/sources/pyside2/plugins/customwidget.cpp @@ -43,11 +43,11 @@ struct PyCustomWidgetPrivate { - PyObject* pyObject; + PyObject *pyObject; bool initialized; }; -PyCustomWidget::PyCustomWidget(PyObject* objectType) +PyCustomWidget::PyCustomWidget(PyObject *objectType) : m_data(new PyCustomWidgetPrivate()) { m_data->pyObject = objectType; @@ -104,13 +104,13 @@ QString PyCustomWidget::whatsThis() const return QString(); } -QWidget* PyCustomWidget::createWidget(QWidget* parent) +QWidget *PyCustomWidget::createWidget(QWidget *parent) { //Create a python instance and return cpp object - PyObject* pyParent; + PyObject *pyParent; bool unkowParent = false; if (parent) { - pyParent = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(parent)); + pyParent = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(parent)); if (pyParent) { Py_INCREF(pyParent); } else { @@ -127,22 +127,22 @@ QWidget* PyCustomWidget::createWidget(QWidget* parent) PyTuple_SET_ITEM(pyArgs, 0, pyParent); //tuple will keep pyParent reference //Call python constructor - SbkObject* result = reinterpret_cast(PyObject_CallObject(m_data->pyObject, pyArgs)); + auto result = reinterpret_cast(PyObject_CallObject(m_data->pyObject, pyArgs)); - QWidget* widget = 0; + QWidget *widget = nullptr; if (result) { if (unkowParent) //if parent does not exists in python, transfer the ownership to cpp Shiboken::Object::releaseOwnership(result); else - Shiboken::Object::setParent(pyParent, reinterpret_cast(result)); + Shiboken::Object::setParent(pyParent, reinterpret_cast(result)); - widget = reinterpret_cast(Shiboken::Object::cppPointer(result, Py_TYPE(result))); + widget = reinterpret_cast(Shiboken::Object::cppPointer(result, Py_TYPE(result))); } return widget; } -void PyCustomWidget::initialize(QDesignerFormEditorInterface* core) +void PyCustomWidget::initialize(QDesignerFormEditorInterface *core) { m_data->initialized = true; } diff --git a/sources/pyside2/plugins/customwidgets.cpp b/sources/pyside2/plugins/customwidgets.cpp index 58d2a518c..e78dde206 100644 --- a/sources/pyside2/plugins/customwidgets.cpp +++ b/sources/pyside2/plugins/customwidgets.cpp @@ -43,21 +43,20 @@ struct PyCustomWidgetPrivate { - PyObject* pyObject; + PyObject *pyObject; bool initialized; }; struct PyCustomWidgetsPrivate { - QList widgets; + QList widgets; ~PyCustomWidgetsPrivate(); }; PyCustomWidgetsPrivate::~PyCustomWidgetsPrivate() { - foreach(QDesignerCustomWidgetInterface* iface, widgets) - delete iface; + qDeleteAll(widgets); widgets.clear(); } @@ -71,12 +70,12 @@ PyCustomWidgets::~PyCustomWidgets() delete m_data; } -void PyCustomWidgets::registerWidgetType(PyObject* widget) +void PyCustomWidgets::registerWidgetType(PyObject *widget) { m_data->widgets.append(new PyCustomWidget(widget)); } -QList PyCustomWidgets::customWidgets() const +QList PyCustomWidgets::customWidgets() const { return m_data->widgets; } diff --git a/sources/pyside2/tests/pysidetest/hiddenobject.cpp b/sources/pyside2/tests/pysidetest/hiddenobject.cpp index 24ef290ea..70692a8ec 100644 --- a/sources/pyside2/tests/pysidetest/hiddenobject.cpp +++ b/sources/pyside2/tests/pysidetest/hiddenobject.cpp @@ -38,7 +38,7 @@ bool HiddenObject::wasCalled() return m_called; } -QObject* getHiddenObject() +QObject *getHiddenObject() { return new HiddenObject(); } diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp index 170a8e1d4..d3a232546 100644 --- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp +++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp @@ -62,7 +62,7 @@ static QString stripTemplateArgs(const QString &name) return pos < 0 ? name : name.left(pos); } -static QStringList parseTemplateType(const QString& name) { +static QStringList parseTemplateType(const QString &name) { int n = name.indexOf(QLatin1Char('<')); if (n <= 0) { // If name starts with '<' or contains an unmatched (i.e. any) '>', we @@ -164,7 +164,7 @@ AbstractMetaEnumList AbstractMetaBuilder::globalEnums() const AbstractMetaEnum *AbstractMetaBuilder::findEnum(const TypeEntry *typeEntry) const { if (typeEntry && typeEntry->isFlags()) - typeEntry = static_cast(typeEntry)->originator(); + typeEntry = static_cast(typeEntry)->originator(); return d->m_enums.value(typeEntry); } @@ -179,7 +179,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() if (!entry->isComplex() || entry->codeGeneration() == TypeEntry::GenerateNothing) continue; - const ComplexTypeEntry* centry = static_cast(entry); + auto centry = static_cast(entry); if (!(centry->codeGeneration() & TypeEntry::GenerateTargetLang)) continue; @@ -226,7 +226,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications() AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument, AbstractMetaClass *currentClass) { - AbstractMetaClass* returned = 0; + AbstractMetaClass *returned = nullptr; AbstractMetaType *type = translateType(argument->type(), currentClass); if (type && type->typeEntry() && type->typeEntry()->isComplex()) { const TypeEntry *entry = type->typeEntry(); @@ -306,7 +306,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte // Strip away first argument, since that is the containing object AbstractMetaArgumentList arguments = metaFunction->arguments(); if (firstArgumentIsSelf || unaryOperator) { - AbstractMetaArgument* first = arguments.takeFirst(); + AbstractMetaArgument *first = arguments.takeFirst(); if (!unaryOperator && first->type()->indirections()) metaFunction->setPointerOperator(true); delete first; @@ -317,7 +317,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelIte // must be an reverse operator (e.g. CLASS::operator(TYPE, CLASS)). // All operator overloads that operate over a class are already // being added as member functions of that class by the API Extractor. - AbstractMetaArgument* last = arguments.takeLast(); + AbstractMetaArgument *last = arguments.takeLast(); if (last->type()->indirections()) metaFunction->setPointerOperator(true); delete last; @@ -479,11 +479,11 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) if (func->accessPolicy() != CodeModel::Public || func->name().startsWith(QLatin1String("operator"))) continue; - FunctionTypeEntry* funcEntry = types->findFunctionType(func->name()); + FunctionTypeEntry *funcEntry = types->findFunctionType(func->name()); if (!funcEntry || !funcEntry->generateCode()) continue; - AbstractMetaFunction* metaFunc = traverseFunction(func, nullptr); + AbstractMetaFunction *metaFunc = traverseFunction(func, nullptr); if (!metaFunc) continue; @@ -551,11 +551,11 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) << QStringLiteral("type '%1' is specified in typesystem, but not defined. This could potentially lead to compilation errors.") .arg(entry->qualifiedCppName()); } else if (entry->generateCode() && entry->type() == TypeEntry::FunctionType) { - const FunctionTypeEntry* fte = static_cast(entry); + auto fte = static_cast(entry); const QStringList &signatures = fte->signatures(); for (const QString &signature : signatures) { bool ok = false; - for (AbstractMetaFunction* func : qAsConst(m_globalFunctions)) { + for (AbstractMetaFunction *func : qAsConst(m_globalFunctions)) { if (signature == func->minimalSignature()) { ok = true; break; @@ -642,7 +642,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) // sort all classes topologically m_metaClasses = classesTopologicalSorted(m_metaClasses); - for (AbstractMetaClass* cls : qAsConst(m_metaClasses)) { + for (AbstractMetaClass *cls : qAsConst(m_metaClasses)) { // setupEquals(cls); // setupComparable(cls); setupClonable(cls); @@ -662,7 +662,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom) // Functions added to the module on the type system. const AddedFunctionList &globalUserFunctions = types->globalUserFunctions(); for (const AddedFunctionPtr &addedFunc : globalUserFunctions) { - AbstractMetaFunction* metaFunc = traverseFunction(addedFunc); + AbstractMetaFunction *metaFunc = traverseFunction(addedFunc); if (Q_UNLIKELY(!metaFunc)) { qFatal("Unable to traverse added global function \"%s\".", qPrintable(addedFunc->name())); @@ -706,7 +706,7 @@ bool AbstractMetaBuilder::build(const QByteArrayList &arguments, return true; } -void AbstractMetaBuilder::setLogDirectory(const QString& logDir) +void AbstractMetaBuilder::setLogDirectory(const QString &logDir) { d->m_logDirectory = logDir; if (!d->m_logDirectory.endsWith(QDir::separator())) @@ -725,7 +725,7 @@ void AbstractMetaBuilderPrivate::addAbstractMetaClass(AbstractMetaClass *cls, } else { m_metaClasses << cls; if (cls->typeEntry()->designatedInterface()) { - AbstractMetaClass* interface = cls->extractInterface(); + AbstractMetaClass *interface = cls->extractInterface(); m_metaClasses << interface; if (ReportHandler::isDebug(ReportHandler::SparseDebug)) qCDebug(lcShiboken) << QStringLiteral(" -> interface '%1'").arg(interface->name()); @@ -784,7 +784,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel const ClassList &classes = namespaceItem->classes(); for (const ClassModelItem &cls : classes) { - AbstractMetaClass* mjc = traverseClass(dom, cls, metaClass); + AbstractMetaClass *mjc = traverseClass(dom, cls, metaClass); if (mjc) { metaClass->addInnerClass(mjc); mjc->setEnclosingClass(metaClass); @@ -806,7 +806,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel // Traverse namespaces recursively for (const NamespaceModelItem &ni : namespaceItem->namespaces()) { - AbstractMetaClass* mjc = traverseNamespace(dom, ni); + AbstractMetaClass *mjc = traverseNamespace(dom, ni); if (mjc) { metaClass->addInnerClass(mjc); mjc->setEnclosingClass(metaClass); @@ -827,7 +827,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & { QString qualifiedName = enumItem->qualifiedName().join(colonColon()); - TypeEntry* typeEntry = 0; + TypeEntry *typeEntry = nullptr; if (enumItem->accessPolicy() == CodeModel::Private) { QStringList names = enumItem->qualifiedName(); const QString &enumName = names.constLast(); @@ -841,7 +841,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & } else { QStringList tmpQualifiedName = enumItem->qualifiedName(); const EnumeratorList &enums = enumItem->enumerators(); - for (const EnumeratorModelItem& enumValue : enums) { + for (const EnumeratorModelItem &enumValue : enums) { tmpQualifiedName.removeLast(); tmpQualifiedName << enumValue->name(); qualifiedName = tmpQualifiedName.join(colonColon()); @@ -964,11 +964,11 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem & return metaEnum; } -AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom, +AbstractMetaClass *AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelItem &dom, const TypeDefModelItem &typeDef, AbstractMetaClass *currentClass) { - TypeDatabase* types = TypeDatabase::instance(); + TypeDatabase *types = TypeDatabase::instance(); QString className = stripTemplateArgs(typeDef->name()); QString fullClassName = className; @@ -981,7 +981,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt // If this is the alias for a primitive type // we store the aliased type on the alias // TypeEntry - PrimitiveTypeEntry* ptype = types->findPrimitiveType(className); + PrimitiveTypeEntry *ptype = types->findPrimitiveType(className); if (ptype) { QString typeDefName = typeDef->type().qualifiedName()[0]; ptype->setReferencedTypeEntry(types->findPrimitiveType(typeDefName)); @@ -990,7 +990,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::traverseTypeDef(const FileModelIt // If we haven't specified anything for the typedef, then we don't care - ComplexTypeEntry* type = types->findComplexType(fullClassName); + ComplexTypeEntry *type = types->findComplexType(fullClassName); if (!type) return 0; @@ -1038,7 +1038,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem + colonColon() + fullClassName; } - ComplexTypeEntry* type = TypeDatabase::instance()->findComplexType(fullClassName); + ComplexTypeEntry *type = TypeDatabase::instance()->findComplexType(fullClassName); AbstractMetaBuilder::RejectReason reason = AbstractMetaBuilder::NoReason; if (TypeDatabase::instance()->isClassRejected(fullClassName)) { @@ -1138,13 +1138,13 @@ void AbstractMetaBuilderPrivate::traverseScopeMembers(ScopeModelItem item, // Inner classes const ClassList &innerClasses = item->classes(); - for (const ClassModelItem& ci : innerClasses) + for (const ClassModelItem &ci : innerClasses) traverseClassMembers(ci); } void AbstractMetaBuilderPrivate::traverseClassMembers(ClassModelItem item) { - AbstractMetaClass* metaClass = m_itemToClass.value(item.data()); + AbstractMetaClass *metaClass = m_itemToClass.value(item.data()); if (!metaClass) return; @@ -1154,7 +1154,7 @@ void AbstractMetaBuilderPrivate::traverseClassMembers(ClassModelItem item) void AbstractMetaBuilderPrivate::traverseNamespaceMembers(NamespaceModelItem item) { - AbstractMetaClass* metaClass = m_itemToClass.value(item.data()); + AbstractMetaClass *metaClass = m_itemToClass.value(item.data()); if (!metaClass) return; @@ -1240,7 +1240,7 @@ void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item { const VariableList &variables = scope_item->variables(); for (const VariableModelItem &field : variables) { - AbstractMetaField* metaField = traverseField(field, metaClass); + AbstractMetaField *metaField = traverseField(field, metaClass); if (metaField && !metaField->isModifiedRemoved()) { metaField->setOriginalAttributes(metaField->attributes()); @@ -1269,7 +1269,7 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF if (!metaFunction->isConversionOperator()) return; - TypeDatabase* types = TypeDatabase::instance(); + TypeDatabase *types = TypeDatabase::instance(); static const QRegularExpression operatorRegExp(QStringLiteral("^operator ")); Q_ASSERT(operatorRegExp.isValid()); QString castTo = metaFunction->name().remove(operatorRegExp).trimmed(); @@ -1279,22 +1279,22 @@ void AbstractMetaBuilderPrivate::fixReturnTypeOfConversionOperator(AbstractMetaF if (castTo.startsWith(QLatin1String("const "))) castTo.remove(0, 6); - TypeEntry* retType = types->findType(castTo); + TypeEntry *retType = types->findType(castTo); if (!retType) return; - AbstractMetaType* metaType = new AbstractMetaType; + AbstractMetaType *metaType = new AbstractMetaType; metaType->setTypeEntry(retType); metaFunction->replaceType(metaType); } -static bool _compareAbstractMetaTypes(const AbstractMetaType* type, const AbstractMetaType* other) +static bool _compareAbstractMetaTypes(const AbstractMetaType *type, const AbstractMetaType *other) { return (type != nullptr) == (other != nullptr) && (type == nullptr || *type == *other); } -static bool _compareAbstractMetaFunctions(const AbstractMetaFunction* func, const AbstractMetaFunction* other) +static bool _compareAbstractMetaFunctions(const AbstractMetaFunction *func, const AbstractMetaFunction *other) { if (!func && !other) return true; @@ -1377,14 +1377,14 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem, *metaFunction += AbstractMetaAttributes::PropertyReader; metaFunction->setPropertySpec(read); } - } else if (QPropertySpec* write = metaClass->propertySpecForWrite(metaFunction->name())) { + } else if (QPropertySpec *write = metaClass->propertySpecForWrite(metaFunction->name())) { // Property setter must be in the form "void name()" // make sure the function was created with all aguments, some argument can be missing during the pareser because of errors on typesystem if ((!metaFunction->type()) && (metaFunction->arguments().size() == 1) && (write->type() == metaFunction->arguments().at(0)->type()->typeEntry())) { *metaFunction += AbstractMetaAttributes::PropertyWriter; metaFunction->setPropertySpec(write); } - } else if (QPropertySpec* reset = metaClass->propertySpecForReset(metaFunction->name())) { + } else if (QPropertySpec *reset = metaClass->propertySpecForReset(metaFunction->name())) { // Property resetter must be in the form "void name()" if ((!metaFunction->type()) && metaFunction->arguments().isEmpty()) { *metaFunction += AbstractMetaAttributes::PropertyResetter; diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp index 512efef58..7bcad504d 100644 --- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp +++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp @@ -963,7 +963,7 @@ QString AbstractMetaFunction::debugSignature() const return result; } -FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass* implementor) const +FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaClass *implementor) const { if (!m_addedFunction.isNull()) return m_addedFunction->modifications; @@ -1042,7 +1042,7 @@ bool AbstractMetaFunction::hasSignatureModifications() const return false; } -bool AbstractMetaFunction::isConversionOperator(const QString& funcName) +bool AbstractMetaFunction::isConversionOperator(const QString &funcName) { static const QRegularExpression opRegEx(QStringLiteral("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$")); Q_ASSERT(opRegEx.isValid()); @@ -1107,7 +1107,7 @@ bool AbstractMetaFunction::generateExceptionHandling() const return result; } -bool AbstractMetaFunction::isOperatorOverload(const QString& funcName) +bool AbstractMetaFunction::isOperatorOverload(const QString &funcName) { if (isConversionOperator(funcName)) return true; @@ -1679,7 +1679,7 @@ bool AbstractMetaClass::hasFunction(const QString &str) const return findFunction(str); } -const AbstractMetaFunction* AbstractMetaClass::findFunction(const QString& functionName) const +const AbstractMetaFunction *AbstractMetaClass::findFunction(const QString &functionName) const { return AbstractMetaFunction::find(m_functions, functionName); } @@ -1732,7 +1732,7 @@ QPropertySpec *AbstractMetaClass::propertySpecForReset(const QString &name) cons return 0; } -typedef QHash AbstractMetaClassBaseTemplateInstantiationsMap; +typedef QHash AbstractMetaClassBaseTemplateInstantiationsMap; Q_GLOBAL_STATIC(AbstractMetaClassBaseTemplateInstantiationsMap, metaClassBaseTemplateInstantiations); bool AbstractMetaClass::hasTemplateBaseClassInstantiations() const @@ -1749,7 +1749,7 @@ AbstractMetaTypeList AbstractMetaClass::templateBaseClassInstantiations() const return metaClassBaseTemplateInstantiations()->value(this); } -void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList& instantiations) +void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList &instantiations) { if (!templateBaseClass()) return; @@ -2018,20 +2018,20 @@ void AbstractMetaClass::addDefaultConstructor() void AbstractMetaClass::addDefaultCopyConstructor(bool isPrivate) { - AbstractMetaFunction* f = new AbstractMetaFunction; + auto f = new AbstractMetaFunction; f->setOriginalName(name()); f->setName(name()); f->setOwnerClass(this); f->setFunctionType(AbstractMetaFunction::CopyConstructorFunction); f->setDeclaringClass(this); - AbstractMetaType* argType = new AbstractMetaType; + auto argType = new AbstractMetaType; argType->setTypeEntry(typeEntry()); argType->setReferenceType(LValueReference); argType->setConstant(true); argType->setTypeUsagePattern(AbstractMetaType::ValuePattern); - AbstractMetaArgument* arg = new AbstractMetaArgument; + auto arg = new AbstractMetaArgument; arg->setType(argType); arg->setName(name()); f->addArgument(arg); @@ -2647,9 +2647,9 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla } AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes, - const TypeEntry* typeEntry) + const TypeEntry *typeEntry) { - for (AbstractMetaClass* c : classes) { + for (AbstractMetaClass *c : classes) { if (c->typeEntry() == typeEntry) return c; } diff --git a/sources/shiboken2/ApiExtractor/typedatabase.h b/sources/shiboken2/ApiExtractor/typedatabase.h index 7f1b2a3fc..df614e644 100644 --- a/sources/shiboken2/ApiExtractor/typedatabase.h +++ b/sources/shiboken2/ApiExtractor/typedatabase.h @@ -72,30 +72,30 @@ public: * \param newInstance This parameter is useful just for unit testing, because singletons causes * too many side effects on unit testing. */ - static TypeDatabase* instance(bool newInstance = false); + static TypeDatabase *instance(bool newInstance = false); static QString normalizedSignature(const QString &signature); QStringList requiredTargetImports() const; - void addRequiredTargetImport(const QString& moduleName); + void addRequiredTargetImport(const QString &moduleName); - void addTypesystemPath(const QString& typesystem_paths); + void addTypesystemPath(const QString &typesystem_paths); - IncludeList extraIncludes(const QString& className) const; + IncludeList extraIncludes(const QString &className) const; - PrimitiveTypeEntry* findPrimitiveType(const QString& name) const; - ComplexTypeEntry* findComplexType(const QString& name) const; - ObjectTypeEntry* findObjectType(const QString& name) const; - NamespaceTypeEntryList findNamespaceTypes(const QString& name) const; - NamespaceTypeEntry *findNamespaceType(const QString& name, const QString &fileName = QString()) const; - ContainerTypeEntry* findContainerType(const QString& name) const; - FunctionTypeEntry* findFunctionType(const QString& name) const; + PrimitiveTypeEntry *findPrimitiveType(const QString &name) const; + ComplexTypeEntry *findComplexType(const QString &name) const; + ObjectTypeEntry *findObjectType(const QString &name) const; + NamespaceTypeEntryList findNamespaceTypes(const QString &name) const; + NamespaceTypeEntry *findNamespaceType(const QString &name, const QString &fileName = QString()) const; + ContainerTypeEntry *findContainerType(const QString &name) const; + FunctionTypeEntry *findFunctionType(const QString &name) const; const TypeSystemTypeEntry *findTypeSystemType(const QString &name) const; const TypeSystemTypeEntry *defaultTypeSystemType() const; QString defaultPackageName() const; - TypeEntry* findType(const QString& name) const; + TypeEntry *findType(const QString &name) const; const TypeEntryMultiMap &entries() const { return m_entries; } const TypedefEntryMap &typedefEntries() const { return m_typedefEntries; } @@ -105,59 +105,59 @@ public: ContainerTypeEntryList containerTypes() const; void addRejection(const TypeRejection &); - bool isClassRejected(const QString& className, QString *reason = nullptr) const; - bool isFunctionRejected(const QString& className, const QString& functionName, + bool isClassRejected(const QString &className, QString *reason = nullptr) const; + bool isFunctionRejected(const QString &className, const QString &functionName, QString *reason = nullptr) const; - bool isFieldRejected(const QString& className, const QString& fieldName, + bool isFieldRejected(const QString &className, const QString &fieldName, QString *reason = nullptr) const; - bool isEnumRejected(const QString& className, const QString& enumName, + bool isEnumRejected(const QString &className, const QString &enumName, QString *reason = nullptr) const; - bool isArgumentTypeRejected(const QString& className, const QString& typeName, + bool isArgumentTypeRejected(const QString &className, const QString &typeName, QString *reason = nullptr) const; - bool isReturnTypeRejected(const QString& className, const QString& typeName, + bool isReturnTypeRejected(const QString &className, const QString &typeName, QString *reason = nullptr) const; - bool addType(TypeEntry* e, QString *errorMessage = nullptr); + bool addType(TypeEntry *e, QString *errorMessage = nullptr); void addTypeSystemType(const TypeSystemTypeEntry *e); - FlagsTypeEntry* findFlagsType(const QString& name) const; - void addFlagsType(FlagsTypeEntry* fte); + FlagsTypeEntry *findFlagsType(const QString &name) const; + void addFlagsType(FlagsTypeEntry *fte); - TemplateEntry *findTemplate(const QString& name) const { return m_templates[name]; } + TemplateEntry *findTemplate(const QString &name) const { return m_templates[name]; } - void addTemplate(TemplateEntry* t); + void addTemplate(TemplateEntry *t); AddedFunctionList globalUserFunctions() const { return m_globalUserFunctions; } void addGlobalUserFunctions(const AddedFunctionList &functions); - AddedFunctionList findGlobalUserFunctions(const QString& name) const; + AddedFunctionList findGlobalUserFunctions(const QString &name) const; void addGlobalUserFunctionModifications(const FunctionModificationList &functionModifications); - FunctionModificationList functionModifications(const QString& signature) const; + FunctionModificationList functionModifications(const QString &signature) const; void setSuppressWarnings(bool on) { m_suppressWarnings = on; } bool addSuppressedWarning(const QString &warning, QString *errorMessage); - bool isSuppressedWarning(const QString& s) const; + bool isSuppressedWarning(const QString &s) const; static QString globalNamespaceClassName(const TypeEntry *te); bool parseFile(const QString &filename, bool generate = true); bool parseFile(const QString &filename, const QString ¤tPath, bool generate); - bool parseFile(QIODevice* device, bool generate = true); + bool parseFile(QIODevice *device, bool generate = true); - static bool setApiVersion(const QString& package, const QString& version); + static bool setApiVersion(const QString &package, const QString &version); static void clearApiVersions(); static bool checkApiVersion(const QString &package, const QVersionNumber &version); bool hasDroppedTypeEntries() const { return !m_dropTypeEntries.isEmpty(); } - bool shouldDropTypeEntry(const QString& fullTypeName) const; + bool shouldDropTypeEntry(const QString &fullTypeName) const; void setDropTypeEntries(QStringList dropTypeEntries); diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp index 49064a6a5..6da9fd933 100644 --- a/sources/shiboken2/generator/generator.cpp +++ b/sources/shiboken2/generator/generator.cpp @@ -153,7 +153,7 @@ QString DefaultValue::constructorParameter() const struct Generator::GeneratorPrivate { - const ApiExtractor* apiextractor = nullptr; + const ApiExtractor *apiextractor = nullptr; QString outDir; // License comment QString licenseComment; @@ -174,7 +174,7 @@ Generator::~Generator() delete m_d; } -bool Generator::setup(const ApiExtractor& extractor) +bool Generator::setup(const ApiExtractor &extractor) { m_d->apiextractor = &extractor; const auto moduleEntry = TypeDatabase::instance()->defaultTypeSystemType(); @@ -188,7 +188,7 @@ bool Generator::setup(const ApiExtractor& extractor) return doSetup(); } -QString Generator::getSimplifiedContainerTypeName(const AbstractMetaType* type) +QString Generator::getSimplifiedContainerTypeName(const AbstractMetaType *type) { const QString signature = type->cppSignature(); if (!type->typeEntry()->isContainer() && !type->typeEntry()->isSmartPointer()) @@ -217,7 +217,7 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType if (!type) return; const AbstractMetaTypeList &instantiations = type->instantiations(); - for (const AbstractMetaType* t : instantiations) + for (const AbstractMetaType *t : instantiations) addInstantiatedContainersAndSmartPointers(t, context); const auto typeEntry = type->typeEntry(); const bool isContainer = typeEntry->isContainer(); @@ -298,7 +298,7 @@ QVector Generator::instantiatedContainers() const return m_d->instantiatedContainers; } -QVector Generator::instantiatedSmartPointers() const +QVector Generator::instantiatedSmartPointers() const { return m_d->instantiatedSmartPointers; } @@ -343,12 +343,12 @@ ContainerTypeEntryList Generator::containerTypes() const return m_d->apiextractor->containerTypes(); } -const AbstractMetaEnum* Generator::findAbstractMetaEnum(const TypeEntry* typeEntry) const +const AbstractMetaEnum *Generator::findAbstractMetaEnum(const TypeEntry *typeEntry) const { return m_d->apiextractor->findAbstractMetaEnum(typeEntry); } -const AbstractMetaEnum* Generator::findAbstractMetaEnum(const AbstractMetaType* metaType) const +const AbstractMetaEnum *Generator::findAbstractMetaEnum(const AbstractMetaType *metaType) const { return m_d->apiextractor->findAbstractMetaEnum(metaType->typeEntry()); } @@ -358,7 +358,7 @@ QString Generator::licenseComment() const return m_d->licenseComment; } -void Generator::setLicenseComment(const QString& licenseComment) +void Generator::setLicenseComment(const QString &licenseComment) { m_d->licenseComment = licenseComment; } @@ -440,12 +440,12 @@ bool Generator::generate() return finishGeneration(); } -bool Generator::shouldGenerateTypeEntry(const TypeEntry* type) const +bool Generator::shouldGenerateTypeEntry(const TypeEntry *type) const { return type->codeGeneration() & TypeEntry::GenerateTargetLang; } -bool Generator::shouldGenerate(const AbstractMetaClass* metaClass) const +bool Generator::shouldGenerate(const AbstractMetaClass *metaClass) const { return shouldGenerateTypeEntry(metaClass->typeEntry()); } @@ -490,7 +490,7 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti } } -QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor) +QTextStream &formatCode(QTextStream &s, const QString &code, Indentor &indentor) { // detect number of spaces before the first character const QStringList lst(code.split(QLatin1Char('\n'))); @@ -527,7 +527,7 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor) return s; } -AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry* type) const +AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry *type) const { if (type->isValue()) { if (const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), type)) @@ -536,52 +536,52 @@ AbstractMetaFunctionList Generator::implicitConversions(const TypeEntry* type) c return AbstractMetaFunctionList(); } -AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType* metaType) const +AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType *metaType) const { return implicitConversions(metaType->typeEntry()); } -bool Generator::isObjectType(const TypeEntry* type) +bool Generator::isObjectType(const TypeEntry *type) { if (type->isComplex()) return Generator::isObjectType(static_cast(type)); return type->isObject(); } -bool Generator::isObjectType(const ComplexTypeEntry* type) +bool Generator::isObjectType(const ComplexTypeEntry *type) { return type->isObject(); } -bool Generator::isObjectType(const AbstractMetaClass* metaClass) +bool Generator::isObjectType(const AbstractMetaClass *metaClass) { return Generator::isObjectType(metaClass->typeEntry()); } -bool Generator::isObjectType(const AbstractMetaType* metaType) +bool Generator::isObjectType(const AbstractMetaType *metaType) { return isObjectType(metaType->typeEntry()); } -bool Generator::isPointer(const AbstractMetaType* type) +bool Generator::isPointer(const AbstractMetaType *type) { return type->indirections() > 0 || type->isNativePointer() || type->isValuePointer(); } -bool Generator::isCString(const AbstractMetaType* type) +bool Generator::isCString(const AbstractMetaType *type) { return type->isNativePointer() && type->indirections() == 1 && type->name() == QLatin1String("char"); } -bool Generator::isVoidPointer(const AbstractMetaType* type) +bool Generator::isVoidPointer(const AbstractMetaType *type) { return type->isNativePointer() && type->indirections() == 1 && type->name() == QLatin1String("void"); } -QString Generator::getFullTypeName(const TypeEntry* type) const +QString Generator::getFullTypeName(const TypeEntry *type) const { QString result = type->qualifiedCppName(); if (type->isArray()) @@ -591,7 +591,7 @@ QString Generator::getFullTypeName(const TypeEntry* type) const return result; } -QString Generator::getFullTypeName(const AbstractMetaType* type) const +QString Generator::getFullTypeName(const AbstractMetaType *type) const { if (isCString(type)) return QLatin1String("const char*"); @@ -607,12 +607,12 @@ QString Generator::getFullTypeName(const AbstractMetaType* type) const return typeName + QString::fromLatin1("*").repeated(type->indirections()); } -QString Generator::getFullTypeName(const AbstractMetaClass* metaClass) const +QString Generator::getFullTypeName(const AbstractMetaClass *metaClass) const { return QLatin1String("::") + metaClass->qualifiedCppName(); } -QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type) const +QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType *type) const { if (isCString(type)) return QLatin1String("const char*"); @@ -638,7 +638,7 @@ QString Generator::getFullTypeNameWithoutModifiers(const AbstractMetaType* type) return QLatin1String("::") + typeName; } -DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const +DefaultValue Generator::minimalConstructor(const AbstractMetaType *type) const { if (!type || (type->referenceType() == LValueReference && Generator::isObjectType(type))) return DefaultValue(DefaultValue::Error); @@ -664,7 +664,7 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const return DefaultValue(DefaultValue::Pointer, QLatin1String("::") + type->typeEntry()->qualifiedCppName()); if (type->typeEntry()->isComplex()) { - const ComplexTypeEntry* cType = static_cast(type->typeEntry()); + auto cType = static_cast(type->typeEntry()); if (cType->hasDefaultConstructor()) return DefaultValue(DefaultValue::Custom, cType->defaultConstructor()); auto ctor = minimalConstructor(AbstractMetaClass::findClass(classes(), cType)); @@ -679,7 +679,7 @@ DefaultValue Generator::minimalConstructor(const AbstractMetaType* type) const return minimalConstructor(type->typeEntry()); } -DefaultValue Generator::minimalConstructor(const TypeEntry* type) const +DefaultValue Generator::minimalConstructor(const TypeEntry *type) const { if (!type) return DefaultValue(DefaultValue::Error); @@ -706,7 +706,7 @@ DefaultValue Generator::minimalConstructor(const TypeEntry* type) const } if (type->isPrimitive()) { - QString ctor = static_cast(type)->defaultConstructor(); + QString ctor = static_cast(type)->defaultConstructor(); // If a non-C++ (i.e. defined by the user) primitive type does not have // a default constructor defined by the user, the empty constructor is // heuristically returned. If this is wrong the build of the generated @@ -729,12 +729,12 @@ static QString constructorCall(const QString &qualifiedCppName, const QStringLis + args.join(QLatin1String(", ")) + QLatin1Char(')'); } -DefaultValue Generator::minimalConstructor(const AbstractMetaClass* metaClass) const +DefaultValue Generator::minimalConstructor(const AbstractMetaClass *metaClass) const { if (!metaClass) return DefaultValue(DefaultValue::Error); - const ComplexTypeEntry* cType = static_cast(metaClass->typeEntry()); + auto cType = static_cast(metaClass->typeEntry()); if (cType->hasDefaultConstructor()) return DefaultValue(DefaultValue::Custom, cType->defaultConstructor()); @@ -845,7 +845,7 @@ QString Generator::translateType(const AbstractMetaType *cType, s = s.remove(index, constLen); } } else if (options & Generator::ExcludeConst || options & Generator::ExcludeReference) { - AbstractMetaType* copyType = cType->copy(); + AbstractMetaType *copyType = cType->copy(); if (options & Generator::ExcludeConst) copyType->setConstant(false); @@ -866,7 +866,7 @@ QString Generator::translateType(const AbstractMetaType *cType, } -QString Generator::subDirectoryForClass(const AbstractMetaClass* clazz) const +QString Generator::subDirectoryForClass(const AbstractMetaClass *clazz) const { return subDirectoryForPackage(clazz->package()); } @@ -880,10 +880,10 @@ QString Generator::subDirectoryForPackage(QString packageNameIn) const } template -static QString getClassTargetFullName_(const T* t, bool includePackageName) +static QString getClassTargetFullName_(const T *t, bool includePackageName) { QString name = t->name(); - const AbstractMetaClass* context = t->enclosingClass(); + const AbstractMetaClass *context = t->enclosingClass(); while (context) { name.prepend(QLatin1Char('.')); name.prepend(context->name()); @@ -896,12 +896,12 @@ static QString getClassTargetFullName_(const T* t, bool includePackageName) return name; } -QString getClassTargetFullName(const AbstractMetaClass* metaClass, bool includePackageName) +QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName) { return getClassTargetFullName_(metaClass, includePackageName); } -QString getClassTargetFullName(const AbstractMetaEnum* metaEnum, bool includePackageName) +QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName) { return getClassTargetFullName_(metaEnum, includePackageName); } diff --git a/sources/shiboken2/generator/generator.h b/sources/shiboken2/generator/generator.h index 04840427f..b7b002ea6 100644 --- a/sources/shiboken2/generator/generator.h +++ b/sources/shiboken2/generator/generator.h @@ -56,11 +56,11 @@ QT_END_NAMESPACE class PrimitiveTypeEntry; class ContainerTypeEntry; -QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor); +QTextStream &formatCode(QTextStream &s, const QString &code, Indentor &indentor); void verifyDirectoryFor(const QString &file); -QString getClassTargetFullName(const AbstractMetaClass* metaClass, bool includePackageName = true); -QString getClassTargetFullName(const AbstractMetaEnum* metaEnum, bool includePackageName = true); +QString getClassTargetFullName(const AbstractMetaClass *metaClass, bool includePackageName = true); +QString getClassTargetFullName(const AbstractMetaEnum *metaEnum, bool includePackageName = true); QString getClassTargetFullName(const AbstractMetaType *metaType, bool includePackageName = true); QString getFilteredCppSignatureString(QString signature); @@ -202,7 +202,7 @@ public: Generator(); virtual ~Generator(); - bool setup(const ApiExtractor& extractor); + bool setup(const ApiExtractor &extractor); virtual OptionDescriptions options() const; virtual bool handleOption(const QString &key, const QString &value); @@ -231,7 +231,7 @@ public: void setLicenseComment(const QString &licenseComment); /// Returns the generator's name. Used for cosmetic purposes. - virtual const char* name() const = 0; + virtual const char *name() const = 0; /** * Retrieves the name of the currently processed module. @@ -250,24 +250,24 @@ public: * \param type a TypeEntry that is expected to be a value-type * \return a list of constructors that could be used as implicit converters */ - AbstractMetaFunctionList implicitConversions(const TypeEntry* type) const; + AbstractMetaFunctionList implicitConversions(const TypeEntry *type) const; - /// Convenience function for implicitConversions(const TypeEntry* type). - AbstractMetaFunctionList implicitConversions(const AbstractMetaType* metaType) const; + /// Convenience function for implicitConversions(const TypeEntry *type). + AbstractMetaFunctionList implicitConversions(const AbstractMetaType *metaType) const; /// Check if type is a pointer. - static bool isPointer(const AbstractMetaType* type); + static bool isPointer(const AbstractMetaType *type); /// Tells if the type or class is an Object (or QObject) Type. - static bool isObjectType(const TypeEntry* type); - static bool isObjectType(const ComplexTypeEntry* type); - static bool isObjectType(const AbstractMetaType* metaType); - static bool isObjectType(const AbstractMetaClass* metaClass); + static bool isObjectType(const TypeEntry *type); + static bool isObjectType(const ComplexTypeEntry *type); + static bool isObjectType(const AbstractMetaType *metaType); + static bool isObjectType(const AbstractMetaClass *metaClass); - /// Returns true if the type is a C string (const char*). - static bool isCString(const AbstractMetaType* type); + /// Returns true if the type is a C string (const char *). + static bool isCString(const AbstractMetaType *type); /// Returns true if the type is a void pointer. - static bool isVoidPointer(const AbstractMetaType* type); + static bool isVoidPointer(const AbstractMetaType *type); protected: /// Returns the classes, topologically ordered, used to generate the binding code. @@ -289,10 +289,10 @@ protected: ContainerTypeEntryList containerTypes() const; /// Returns an AbstractMetaEnum for a given TypeEntry that is an EnumTypeEntry, or nullptr if not found. - const AbstractMetaEnum* findAbstractMetaEnum(const TypeEntry* typeEntry) const; + const AbstractMetaEnum *findAbstractMetaEnum(const TypeEntry *typeEntry) const; /// Returns an AbstractMetaEnum for a given AbstractMetaType that holds an EnumTypeEntry, or nullptr if not found. - const AbstractMetaEnum* findAbstractMetaEnum(const AbstractMetaType* metaType) const; + const AbstractMetaEnum *findAbstractMetaEnum(const AbstractMetaType *metaType) const; /// Generates a file for given AbstractMetaClass or AbstractMetaType (smart pointer case). bool generateFileForContext(GeneratorContext &context); @@ -302,13 +302,13 @@ protected: const AbstractMetaClass *smartPointerClass) const; /// Returns true if the generator should generate any code for the TypeEntry. - bool shouldGenerateTypeEntry(const TypeEntry*) const; + bool shouldGenerateTypeEntry(const TypeEntry *) const; /// Returns true if the generator should generate any code for the AbstractMetaClass. virtual bool shouldGenerate(const AbstractMetaClass *) const; /// Returns the subdirectory used to write the binding code of an AbstractMetaClass. - virtual QString subDirectoryForClass(const AbstractMetaClass* clazz) const; + virtual QString subDirectoryForClass(const AbstractMetaClass *clazz) const; /** * Translate metatypes to binding source format. @@ -344,25 +344,25 @@ protected: QString packageName() const; // Returns the full name of the type. - QString getFullTypeName(const TypeEntry* type) const; - QString getFullTypeName(const AbstractMetaType* type) const; - QString getFullTypeName(const AbstractMetaClass* metaClass) const; + QString getFullTypeName(const TypeEntry *type) const; + QString getFullTypeName(const AbstractMetaType *type) const; + QString getFullTypeName(const AbstractMetaClass *metaClass) const; /** * Returns the full qualified C++ name for an AbstractMetaType, but removing modifiers * as 'const', '&', and '*' (except if the class is not derived from a template). * This is useful for instantiated templates. */ - QString getFullTypeNameWithoutModifiers(const AbstractMetaType* type) const; + QString getFullTypeNameWithoutModifiers(const AbstractMetaType *type) const; /** * Tries to build a minimal constructor for the type. * It will check first for a user defined default constructor. * Returns a null string if it fails. */ - DefaultValue minimalConstructor(const TypeEntry* type) const; - DefaultValue minimalConstructor(const AbstractMetaType* type) const; - DefaultValue minimalConstructor(const AbstractMetaClass* metaClass) const; + DefaultValue minimalConstructor(const TypeEntry *type) const; + DefaultValue minimalConstructor(const AbstractMetaType *type) const; + DefaultValue minimalConstructor(const AbstractMetaClass *metaClass) const; /** * Returns the file name used to write the binding code of an AbstractMetaClass/Type. @@ -382,7 +382,7 @@ protected: * \param s text stream to write the generated output * \param metaClass the class that should be generated */ - virtual void generateClass(QTextStream& s, GeneratorContext &classContext) = 0; + virtual void generateClass(QTextStream &s, GeneratorContext &classContext) = 0; virtual bool finishGeneration() = 0; /** @@ -396,8 +396,8 @@ protected: */ virtual QString subDirectoryForPackage(QString packageName = QString()) const; - QVector instantiatedContainers() const; - QVector instantiatedSmartPointers() const; + QVector instantiatedContainers() const; + QVector instantiatedSmartPointers() const; static QString getSimplifiedContainerTypeName(const AbstractMetaType *type); void addInstantiatedContainersAndSmartPointers(const AbstractMetaType *type, @@ -407,8 +407,8 @@ private: bool useEnumAsIntForProtectedHack(const AbstractMetaType *cType) const; struct GeneratorPrivate; - GeneratorPrivate* m_d; - void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction* func); + GeneratorPrivate *m_d; + void collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func); void collectInstantiatedContainersAndSmartPointers(const AbstractMetaClass *metaClass); void collectInstantiatedContainersAndSmartPointers(); }; diff --git a/sources/shiboken2/generator/main.cpp b/sources/shiboken2/generator/main.cpp index ac576d657..4c84e0d47 100644 --- a/sources/shiboken2/generator/main.cpp +++ b/sources/shiboken2/generator/main.cpp @@ -63,7 +63,7 @@ typedef QMap CommandArgumentMap; typedef Generator::OptionDescriptions OptionDescriptions; -static void printOptions(QTextStream& s, const OptionDescriptions& options) +static void printOptions(QTextStream &s, const OptionDescriptions &options) { s.setFieldAlignment(QTextStream::AlignLeft); for (const auto &od : options) { @@ -82,7 +82,7 @@ static void printOptions(QTextStream& s, const OptionDescriptions& options) } } -static bool processProjectFile(QFile& projectFile, QMap& args) +static bool processProjectFile(QFile &projectFile, QMap &args) { QByteArray line = projectFile.readLine().trimmed(); if (line.isEmpty() || line != "[generator-project]") @@ -355,7 +355,7 @@ static inline void printVerAndBanner() std::cout << "Copyright (C) 2016 The Qt Company Ltd." << std::endl; } -static inline void errorPrint(const QString& s) +static inline void errorPrint(const QString &s) { QStringList arguments = QCoreApplication::arguments(); arguments.pop_front(); diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp index c033b8a21..73e1a7c3e 100644 --- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp +++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp @@ -81,7 +81,7 @@ static const char *typeNameOf(const T &t) )CPP"; // utility functions -inline AbstractMetaType* getTypeWithoutContainer(AbstractMetaType* arg) +inline AbstractMetaType *getTypeWithoutContainer(AbstractMetaType *arg) { if (arg && arg->typeEntry()->isContainer()) { AbstractMetaTypeList lst = arg->instantiations(); @@ -144,25 +144,25 @@ CppGenerator::CppGenerator() // sequence protocol functions m_sequenceProtocol.insert(QLatin1String("__len__"), - {QLatin1String("PyObject* self"), + {QLatin1String("PyObject *self"), QLatin1String("Py_ssize_t")}); m_sequenceProtocol.insert(QLatin1String("__getitem__"), - {QLatin1String("PyObject* self, Py_ssize_t _i"), + {QLatin1String("PyObject *self, Py_ssize_t _i"), QLatin1String("PyObject*")}); m_sequenceProtocol.insert(QLatin1String("__setitem__"), - {QLatin1String("PyObject* self, Py_ssize_t _i, PyObject* _value"), + {QLatin1String("PyObject *self, Py_ssize_t _i, PyObject *_value"), QLatin1String("int")}); m_sequenceProtocol.insert(QLatin1String("__getslice__"), - {QLatin1String("PyObject* self, Py_ssize_t _i1, Py_ssize_t _i2"), + {QLatin1String("PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2"), QLatin1String("PyObject*")}); m_sequenceProtocol.insert(QLatin1String("__setslice__"), - {QLatin1String("PyObject* self, Py_ssize_t _i1, Py_ssize_t _i2, PyObject* _value"), + {QLatin1String("PyObject *self, Py_ssize_t _i1, Py_ssize_t _i2, PyObject *_value"), QLatin1String("int")}); m_sequenceProtocol.insert(QLatin1String("__contains__"), - {QLatin1String("PyObject* self, PyObject* _value"), + {QLatin1String("PyObject *self, PyObject *_value"), QLatin1String("int")}); m_sequenceProtocol.insert(QLatin1String("__concat__"), - {QLatin1String("PyObject* self, PyObject* _other"), + {QLatin1String("PyObject *self, PyObject *_other"), QLatin1String("PyObject*")}); // Sequence protocol structure members names @@ -176,13 +176,13 @@ CppGenerator::CppGenerator() // mapping protocol function m_mappingProtocol.insert(QLatin1String("__mlen__"), - {QLatin1String("PyObject* self"), + {QLatin1String("PyObject *self"), QLatin1String("Py_ssize_t")}); m_mappingProtocol.insert(QLatin1String("__mgetitem__"), - {QLatin1String("PyObject* self, PyObject* _key"), + {QLatin1String("PyObject *self, PyObject *_key"), QLatin1String("PyObject*")}); m_mappingProtocol.insert(QLatin1String("__msetitem__"), - {QLatin1String("PyObject* self, PyObject* _key, PyObject* _value"), + {QLatin1String("PyObject *self, PyObject *_key, PyObject *_value"), QLatin1String("int")}); // Sequence protocol structure members names @@ -210,8 +210,8 @@ QString CppGenerator::fileNameForContext(GeneratorContext &context) const } } -QVector CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass, - uint queryIn) +QVector CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass, + uint queryIn) { // ( func_name, num_args ) => func_list typedef QMap, AbstractMetaFunctionList> ResultMap; @@ -242,15 +242,15 @@ QVector CppGenerator::filterGroupedOperatorFunctions(c return result; } -const AbstractMetaFunction *CppGenerator::boolCast(const AbstractMetaClass* metaClass) const +const AbstractMetaFunction *CppGenerator::boolCast(const AbstractMetaClass *metaClass) const { if (!useIsNullAsNbNonZero()) return nullptr; // TODO: This could be configurable someday - const AbstractMetaFunction* func = metaClass->findFunction(QLatin1String("isNull")); + const AbstractMetaFunction *func = metaClass->findFunction(QLatin1String("isNull")); if (!func || !func->type() || !func->type()->typeEntry()->isPrimitive() || !func->isPublic()) return nullptr; - const PrimitiveTypeEntry* pte = static_cast(func->type()->typeEntry()); + auto pte = static_cast(func->type()->typeEntry()); while (pte->referencedTypeEntry()) pte = pte->referencedTypeEntry(); return func && func->isConstant() && pte->name() == QLatin1String("bool") @@ -489,7 +489,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext) if (overloads.isEmpty()) continue; - const AbstractMetaFunction* rfunc = overloads.constFirst(); + const AbstractMetaFunction *rfunc = overloads.constFirst(); if (m_sequenceProtocol.contains(rfunc->name()) || m_mappingProtocol.contains(rfunc->name())) continue; @@ -587,7 +587,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext) if (const AbstractMetaFunction *f = boolCast(metaClass)) { ErrorCode errorCode(-1); - s << "static int " << cpythonBaseName(metaClass) << "___nb_bool(PyObject* self)" << endl; + s << "static int " << cpythonBaseName(metaClass) << "___nb_bool(PyObject *self)" << endl; s << '{' << endl; writeCppSelfDefinition(s, classContext); if (f->allowThread()) { @@ -656,7 +656,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext) if (metaField->isStatic()) continue; - s << INDENT << "{const_cast(\"" << metaField->name() << "\"), "; + s << INDENT << "{const_cast(\"" << metaField->name() << "\"), "; s << cpythonGetterFunctionName(metaField) << ", "; if (canGenerateFieldSetter(metaField)) s << cpythonSetterFunctionName(metaField); @@ -707,7 +707,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext) } } -void CppGenerator::writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func) +void CppGenerator::writeConstructorNative(QTextStream &s, const AbstractMetaFunction *func) { Indentation indentation(INDENT); s << functionSignature(func, wrapperName(func->ownerClass()) + QLatin1String("::"), QString(), @@ -715,7 +715,7 @@ void CppGenerator::writeConstructorNative(QTextStream& s, const AbstractMetaFunc s << " : "; writeFunctionCall(s, func); s << endl << "{" << endl; - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg); s << INDENT << "// ... middle" << endl; writeCodeSnips(s, func->injectedCodeSnips(), TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg); @@ -727,12 +727,12 @@ void CppGenerator::writeDestructorNative(QTextStream &s, const AbstractMetaClass Indentation indentation(INDENT); s << wrapperName(metaClass) << "::~" << wrapperName(metaClass) << "()" << endl << '{' << endl; // kill pyobject - s << INDENT << "SbkObject* wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; + s << INDENT << "SbkObject *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; s << INDENT << "Shiboken::Object::destroy(wrapper, this);" << endl; s << '}' << endl; } -static bool allArgumentsRemoved(const AbstractMetaFunction* func) +static bool allArgumentsRemoved(const AbstractMetaFunction *func) { if (func->arguments().isEmpty()) return false; @@ -744,7 +744,7 @@ static bool allArgumentsRemoved(const AbstractMetaFunction* func) return true; } -QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction* func) +QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func) { if (!func->type()) return QLatin1String("\"\""); @@ -755,12 +755,12 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio // SbkType would return null when the type is a container. if (func->type()->typeEntry()->isContainer()) { return QLatin1Char('"') - + reinterpret_cast(func->type()->typeEntry())->typeName() + + reinterpret_cast(func->type()->typeEntry())->typeName() + QLatin1Char('"'); } if (avoidProtectedHack()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(func->type()); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type()); if (metaEnum && metaEnum->isProtected()) return QLatin1Char('"') + protectedEnumSurrogateName(metaEnum) + QLatin1Char('"'); } @@ -771,14 +771,14 @@ QString CppGenerator::getVirtualFunctionReturnTypeName(const AbstractMetaFunctio return QString::fromLatin1("reinterpret_cast(Shiboken::SbkType< %1 >())->tp_name").arg(func->type()->typeEntry()->qualifiedCppName()); } -void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFunction* func) +void CppGenerator::writeVirtualMethodNative(QTextStream &s, const AbstractMetaFunction *func) { //skip metaObject function, this will be written manually ahead if (usePySideExtensions() && func->ownerClass() && func->ownerClass()->isQObject() && ((func->name() == QLatin1String("metaObject")) || (func->name() == QLatin1String("qt_metacall")))) return; - const TypeEntry* retType = func->type() ? func->type()->typeEntry() : 0; + const TypeEntry *retType = func->type() ? func->type()->typeEntry() : nullptr; const QString funcName = func->isOperatorOverload() ? pythonOperatorFunctionName(func) : func->name(); QString prefix = wrapperName(func->ownerClass()) + QLatin1String("::"); @@ -841,7 +841,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun //Write declaration/native injected code if (func->hasInjectedCode()) { CodeSnipList snips = func->injectedCodeSnips(); - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionDeclaration, TypeSystem::NativeCode, func, lastArg); s << endl; } @@ -864,7 +864,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun CodeSnipList snips; if (func->hasInjectedCode()) { snips = func->injectedCodeSnips(); - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::ShellCode, func, lastArg); s << endl; } @@ -905,7 +905,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun QString argConv; QTextStream ac(&argConv); - const PrimitiveTypeEntry* argType = (const PrimitiveTypeEntry*) arg->type()->typeEntry(); + auto argType = static_cast(arg->type()->typeEntry()); bool convert = argType->isObject() || argType->isValue() || arg->type()->isValuePointer() @@ -963,9 +963,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun snips = func->injectedCodeSnips(); if (injectedCodeUsesPySelf(func)) - s << INDENT << "PyObject* pySelf = BindingManager::instance().retrieveWrapper(this);" << endl; + s << INDENT << "PyObject *pySelf = BindingManager::instance().retrieveWrapper(this);" << endl; - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionBeginning, TypeSystem::NativeCode, func, lastArg); s << endl; } @@ -1067,14 +1067,14 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun if (func->hasInjectedCode()) { s << endl; - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionEnd, TypeSystem::NativeCode, func, lastArg); } if (retType) { s << INDENT << "return "; if (avoidProtectedHack() && retType->isEnum()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(retType); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(retType); bool isProtectedEnum = metaEnum && metaEnum->isProtected(); if (isProtectedEnum) { QString typeCast; @@ -1085,29 +1085,29 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun } } if (func->type()->referenceType() == LValueReference && !isPointer(func->type())) - s << '*'; + s << " *"; s << CPP_RETURN_VAR << ';' << endl; } s << '}' << endl << endl; } -void CppGenerator::writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeMetaObjectMethod(QTextStream &s, const AbstractMetaClass *metaClass) { Indentation indentation(INDENT); QString wrapperClassName = wrapperName(metaClass); - s << "const QMetaObject* " << wrapperClassName << "::metaObject() const" << endl; + s << "const QMetaObject *" << wrapperClassName << "::metaObject() const" << endl; s << '{' << endl; s << INDENT << "if (QObject::d_ptr->metaObject)" << endl << INDENT << INDENT << "return QObject::d_ptr->dynamicMetaObject();" << endl; - s << INDENT << "SbkObject* pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; + s << INDENT << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; s << INDENT << "if (pySelf == nullptr)" << endl; s << INDENT << INDENT << "return " << metaClass->qualifiedCppName() << "::metaObject();" << endl; - s << INDENT << "return PySide::SignalManager::retrieveMetaObject(reinterpret_cast(pySelf));" << endl; + s << INDENT << "return PySide::SignalManager::retrieveMetaObject(reinterpret_cast(pySelf));" << endl; s << '}' << endl << endl; // qt_metacall function - s << "int " << wrapperClassName << "::qt_metacall(QMetaObject::Call call, int id, void** args)" << endl; + s << "int " << wrapperClassName << "::qt_metacall(QMetaObject::Call call, int id, void **args)" << endl; s << "{" << endl; AbstractMetaFunction *func = nullptr; @@ -1132,28 +1132,28 @@ void CppGenerator::writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass writeMetaCast(s, metaClass); } -void CppGenerator::writeMetaCast(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeMetaCast(QTextStream &s, const AbstractMetaClass *metaClass) { Indentation indentation(INDENT); QString wrapperClassName = wrapperName(metaClass); - s << "void* " << wrapperClassName << "::qt_metacast(const char* _clname)" << endl; + s << "void *" << wrapperClassName << "::qt_metacast(const char *_clname)" << endl; s << '{' << endl; s << INDENT << "if (!_clname) return {};" << endl; - s << INDENT << "SbkObject* pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; + s << INDENT << "SbkObject *pySelf = Shiboken::BindingManager::instance().retrieveWrapper(this);" << endl; s << INDENT << "if (pySelf && PySide::inherits(Py_TYPE(pySelf), _clname))" << endl; - s << INDENT << INDENT << "return static_cast(const_cast< " << wrapperClassName << "* >(this));" << endl; + s << INDENT << INDENT << "return static_cast(const_cast< " << wrapperClassName << " *>(this));" << endl; s << INDENT << "return " << metaClass->qualifiedCppName() << "::qt_metacast(_clname);" << endl; s << "}" << endl << endl; } -void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const AbstractMetaEnum* metaEnum) +void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum) { if (metaEnum->isPrivate() || metaEnum->isAnonymous()) return; writeEnumConverterFunctions(s, metaEnum->typeEntry()); } -void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* enumType) +void CppGenerator::writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType) { if (!enumType) return; @@ -1161,16 +1161,16 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* QString enumPythonType = cpythonTypeNameExt(enumType); QString cppTypeName = getFullTypeName(enumType).trimmed(); if (avoidProtectedHack()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(enumType); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(enumType); if (metaEnum && metaEnum->isProtected()) cppTypeName = protectedEnumSurrogateName(metaEnum); } QString code; QTextStream c(&code); - c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n" + c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n" << INDENT << " "; if (enumType->isFlags()) - c << cppTypeName << "(QFlag(int(PySide::QFlags::getValue(reinterpret_cast(pyIn)))))"; + c << cppTypeName << "(QFlag(int(PySide::QFlags::getValue(reinterpret_cast(pyIn)))))"; else c << "static_cast<" << cppTypeName << ">(Shiboken::Enum::getValue(pyIn))"; c << ';' << endl; @@ -1186,7 +1186,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* c << INDENT; c << "return "; if (enumType->isFlags()) { - c << "reinterpret_cast(PySide::QFlags::newObject(castCppIn, " + c << "reinterpret_cast(PySide::QFlags::newObject(castCppIn, " << enumPythonType << "))"; } else { c << "Shiboken::Enum::newItem(" << enumPythonType << ", castCppIn)"; @@ -1198,7 +1198,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* if (enumType->isFlags()) return; - const FlagsTypeEntry* flags = reinterpret_cast(enumType)->flags(); + auto flags = reinterpret_cast(enumType)->flags(); if (!flags) return; @@ -1208,7 +1208,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* code.clear(); cppTypeName = getFullTypeName(flags).trimmed(); - c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n" + c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n" << INDENT << " " << cppTypeName << "(QFlag(int(Shiboken::Enum::getValue(pyIn))));" << endl; @@ -1218,7 +1218,7 @@ void CppGenerator::writeEnumConverterFunctions(QTextStream& s, const TypeEntry* code.clear(); c << INDENT << "Shiboken::AutoDecRef pyLong(PyNumber_Long(pyIn));" << endl; - c << INDENT << "*reinterpret_cast<" << cppTypeName << "*>(cppOut) =\n" + c << INDENT << "*reinterpret_cast<" << cppTypeName << " *>(cppOut) =\n" << INDENT << " " << cppTypeName << "(QFlag(int(PyLong_AsLong(pyLong.object()))));" << endl; // PYSIDE-898: Include an additional condition to detect if the type of the @@ -1270,7 +1270,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla writePythonToCppFunction(s, code, sourceTypeName, targetTypeName); // "Is convertible" function for the Python object to C++ pointer conversion. - const QString pyTypeCheck = QLatin1String("PyObject_TypeCheck(pyIn, reinterpret_cast(") + const QString pyTypeCheck = QLatin1String("PyObject_TypeCheck(pyIn, reinterpret_cast(") + cpythonType + QLatin1String("))"); writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, pyTypeCheck, QString(), true); s << endl; @@ -1281,9 +1281,9 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla if (usePySideExtensions() && metaClass->isQObject()) { c << INDENT << "return PySide::getWrapperForQObject(reinterpret_cast<" - << typeName << "*>(const_cast(cppIn)), " << cpythonType << ");" << endl; + << typeName << " *>(const_cast(cppIn)), " << cpythonType << ");" << endl; } else { - c << INDENT << "auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));" << endl; + c << INDENT << "auto pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));" << endl; c << INDENT << "if (pyOut) {" << endl; { Indentation indent(INDENT); @@ -1300,7 +1300,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla << INDENT << " changedTypeName = true;\n" << INDENT << " }\n" << INDENT << "PyObject *result = Shiboken::Object::newObject(" << cpythonType - << ", const_cast(cppIn), false, /* exactType */ changedTypeName, typeName);\n" + << ", const_cast(cppIn), false, /* exactType */ changedTypeName, typeName);\n" << INDENT << "if (changedTypeName)\n" << INDENT << " delete [] typeName;\n" << INDENT << "return result;"; @@ -1333,7 +1333,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla c << INDENT << "return Shiboken::Object::newObject(" << cpythonType << ", new ::" << computedWrapperName << "(*reinterpret_cast(cppIn)), true, true);"; + << typeName << " *>(cppIn)), true, true);"; writeCppToPythonFunction(s, code, sourceTypeName, targetTypeName); s << endl; @@ -1354,7 +1354,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla else wrappedCPtrExpression = cpythonWrapperCPtr(classContext.preciseType(), pyInVariable); - c << INDENT << "*reinterpret_cast<" << typeName << "*>(cppOut) = *" + c << INDENT << "*reinterpret_cast<" << typeName << " *>(cppOut) = *" << wrappedCPtrExpression << ';'; writePythonToCppFunction(s, code, sourceTypeName, targetTypeName); @@ -1363,7 +1363,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla s << endl; // User provided implicit conversions. - CustomConversion* customConversion = metaClass->typeEntry()->customConversion(); + CustomConversion *customConversion = metaClass->typeEntry()->customConversion(); // Implicit conversions. AbstractMetaFunctionList implicitConvs; @@ -1378,8 +1378,8 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla if (!implicitConvs.isEmpty()) s << "// Implicit conversions." << endl; - AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass); - for (const AbstractMetaFunction* conv : qAsConst(implicitConvs)) { + AbstractMetaType *targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass); + for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) { if (conv->isModifiedRemoved()) continue; @@ -1387,14 +1387,14 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla QString toCppConv; QString toCppPreConv; if (conv->isConversionOperator()) { - const AbstractMetaClass* sourceClass = conv->ownerClass(); + const AbstractMetaClass *sourceClass = conv->ownerClass(); typeCheck = QStringLiteral("PyObject_TypeCheck(pyIn, %1)").arg(cpythonTypeNameExt(sourceClass->typeEntry())); toCppConv = QLatin1Char('*') + cpythonWrapperCPtr(sourceClass->typeEntry(), QLatin1String("pyIn")); } else { // Constructor that does implicit conversion. if (!conv->typeReplaced(1).isEmpty() || conv->isModifiedToArray(1)) continue; - const AbstractMetaType* sourceType = conv->arguments().constFirst()->type(); + const AbstractMetaType *sourceType = conv->arguments().constFirst()->type(); typeCheck = cpythonCheckFunction(sourceType); bool isUserPrimitiveWithoutTargetLangName = isUserPrimitive(sourceType) && sourceType->typeEntry()->targetLangApiName() == sourceType->typeEntry()->name(); @@ -1408,7 +1408,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla if (isWrapperType(sourceType)) { typeCheck += QLatin1String("pyIn)"); toCppConv = (sourceType->referenceType() == LValueReference || !isPointerToWrapperType(sourceType)) - ? QLatin1String("*") : QString(); + ? QLatin1String(" *") : QString(); toCppConv += cpythonWrapperCPtr(sourceType->typeEntry(), QLatin1String("pyIn")); } else if (typeCheck.contains(QLatin1String("%in"))) { typeCheck.replace(QLatin1String("%in"), QLatin1String("pyIn")); @@ -1436,7 +1436,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla } - const AbstractMetaType* sourceType = conv->isConversionOperator() + const AbstractMetaType *sourceType = conv->isConversionOperator() ? buildAbstractMetaTypeFromAbstractMetaClass(conv->ownerClass()) : conv->arguments().constFirst()->type(); writePythonToCppConversionFunctions(s, sourceType, targetType, typeCheck, toCppConv, toCppPreConv); @@ -1445,11 +1445,11 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla writeCustomConverterFunctions(s, customConversion); } -void CppGenerator::writeCustomConverterFunctions(QTextStream& s, const CustomConversion* customConversion) +void CppGenerator::writeCustomConverterFunctions(QTextStream &s, const CustomConversion *customConversion) { if (!customConversion) return; - const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions(); + const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions(); if (toCppConversions.isEmpty()) return; s << "// Python to C++ conversions for type '" << customConversion->ownerType()->qualifiedCppName() << "'." << endl; @@ -1464,7 +1464,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas if (metaClass->isNamespace()) return; s << INDENT << "// Register Converter" << endl; - s << INDENT << "SbkConverter* converter = Shiboken::Conversions::createConverter("; + s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter("; s << cpythonTypeName(metaClass) << ',' << endl; { Indentation indent(INDENT); @@ -1528,7 +1528,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas writeAddPythonToCppConversion(s, QLatin1String("converter"), toCpp, isConv); // User provided implicit conversions. - CustomConversion* customConversion = metaClass->typeEntry()->customConversion(); + CustomConversion *customConversion = metaClass->typeEntry()->customConversion(); // Add implicit conversions. AbstractMetaFunctionList implicitConvs; @@ -1543,11 +1543,11 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas if (!implicitConvs.isEmpty()) s << INDENT << "// Add implicit conversions to type converter." << endl; - AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass); + AbstractMetaType *targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass); for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) { if (conv->isModifiedRemoved()) continue; - const AbstractMetaType* sourceType; + const AbstractMetaType *sourceType; if (conv->isConversionOperator()) { sourceType = buildAbstractMetaTypeFromAbstractMetaClass(conv->ownerClass()); } else { @@ -1564,11 +1564,11 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas writeCustomConverterRegister(s, customConversion, QLatin1String("converter")); } -void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConversion* customConversion, const QString& converterVar) +void CppGenerator::writeCustomConverterRegister(QTextStream &s, const CustomConversion *customConversion, const QString &converterVar) { if (!customConversion) return; - const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions(); + const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions(); if (toCppConversions.isEmpty()) return; s << INDENT << "// Add user defined implicit conversions to type converter." << endl; @@ -1579,7 +1579,7 @@ void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConv } } -void CppGenerator::writeContainerConverterFunctions(QTextStream& s, const AbstractMetaType* containerType) +void CppGenerator::writeContainerConverterFunctions(QTextStream &s, const AbstractMetaType *containerType) { writeCppToPythonFunction(s, containerType); writePythonToCppConversionFunctions(s, containerType); @@ -1588,8 +1588,8 @@ void CppGenerator::writeContainerConverterFunctions(QTextStream& s, const Abstra void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &overloadData, GeneratorContext &context) { - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); - const AbstractMetaClass* ownerClass = rfunc->ownerClass(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); + const AbstractMetaClass *ownerClass = rfunc->ownerClass(); int minArgs = overloadData.minArgs(); int maxArgs = overloadData.maxArgs(); bool initPythonArguments; @@ -1619,7 +1619,7 @@ void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &over } else { s << context.preciseType()->cppSignature(); } - s << "* cptr{};" << endl; + s << " *cptr{};" << endl; initPythonArguments = maxArgs > 0; usesNamedArguments = !ownerClass->isQObject() && overloadData.hasArgumentWithDefaultValue(); @@ -1630,7 +1630,7 @@ void CppGenerator::writeMethodWrapperPreamble(QTextStream &s, OverloadData &over writeCppSelfDefinition(s, rfunc, context, overloadData.hasStaticFunction()); } if (!rfunc->isInplaceOperator() && overloadData.hasNonVoidReturnType()) - s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << "{};" << endl; + s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << "{};" << endl; initPythonArguments = minArgs != maxArgs || maxArgs > 1; usesNamedArguments = rfunc->isCallOperator() || overloadData.hasArgumentWithDefaultValue(); @@ -1668,11 +1668,11 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun ErrorCode errorCode(-1); OverloadData overloadData(overloads, this); - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); - const AbstractMetaClass* metaClass = rfunc->ownerClass(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); + const AbstractMetaClass *metaClass = rfunc->ownerClass(); s << "static int" << endl; - s << cpythonFunctionName(rfunc) << "(PyObject* self, PyObject* args, PyObject* kwds)" << endl; + s << cpythonFunctionName(rfunc) << "(PyObject *self, PyObject *args, PyObject *kwds)" << endl; s << '{' << endl; QSet argNamesSet; @@ -1690,19 +1690,19 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun QStringList argNamesList = argNamesSet.toList(); std::sort(argNamesList.begin(), argNamesList.end()); if (argNamesList.isEmpty()) { - s << INDENT << "const char** argNames{};" << endl; + s << INDENT << "const char **argNames{};" << endl; } else { - s << INDENT << "const char* argNames[] = {\"" + s << INDENT << "const char *argNames[] = {\"" << argNamesList.join(QLatin1String("\", \"")) << "\"};" << endl; } - s << INDENT << "const QMetaObject* metaObject;" << endl; + s << INDENT << "const QMetaObject *metaObject;" << endl; } - s << INDENT << "SbkObject* sbkSelf = reinterpret_cast(self);" << endl; + s << INDENT << "SbkObject *sbkSelf = reinterpret_cast(self);" << endl; if (metaClass->isAbstract() || metaClass->baseClassNames().size() > 1) { - s << INDENT << "SbkObjectType* type = reinterpret_cast(self->ob_type);" << endl; - s << INDENT << "SbkObjectType* myType = reinterpret_cast(" << cpythonTypeNameExt(metaClass->typeEntry()) << ");" << endl; + s << INDENT << "SbkObjectType *type = reinterpret_cast(self->ob_type);" << endl; + s << INDENT << "SbkObjectType *myType = reinterpret_cast(" << cpythonTypeNameExt(metaClass->typeEntry()) << ");" << endl; } if (metaClass->isAbstract()) { @@ -1827,16 +1827,16 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction GeneratorContext &classContext) { OverloadData overloadData(overloads, this); - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); int maxArgs = overloadData.maxArgs(); - s << "static PyObject* "; - s << cpythonFunctionName(rfunc) << "(PyObject* self"; + s << "static PyObject *"; + s << cpythonFunctionName(rfunc) << "(PyObject *self"; if (maxArgs > 0) { - s << ", PyObject* " << (pythonFunctionWrapperUsesListOfArguments(overloadData) ? "args" : PYTHON_ARG); + s << ", PyObject *" << (pythonFunctionWrapperUsesListOfArguments(overloadData) ? "args" : PYTHON_ARG); if (overloadData.hasArgumentWithDefaultValue() || rfunc->isCallOperator()) - s << ", PyObject* kwds"; + s << ", PyObject *kwds"; } s << ')' << endl << '{' << endl; @@ -1868,17 +1868,17 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction Indentation indent(INDENT); s << INDENT << "&& Shiboken::Object::checkType(" << PYTHON_ARG << ")" << endl; s << INDENT << "&& !PyObject_TypeCheck(" << PYTHON_ARG << ", self->ob_type)" << endl; - s << INDENT << "&& PyObject_HasAttrString(" << PYTHON_ARG << ", const_cast(\"" << revOpName << "\"))) {" << endl; + s << INDENT << "&& PyObject_HasAttrString(" << PYTHON_ARG << ", const_cast(\"" << revOpName << "\"))) {" << endl; // This PyObject_CallMethod call will emit lots of warnings like // "deprecated conversion from string constant to char *" during compilation - // due to the method name argument being declared as "char*" instead of "const char*" + // due to the method name argument being declared as "char *" instead of "const char *" // issue 6952 http://bugs.python.org/issue6952 - s << INDENT << "PyObject* revOpMethod = PyObject_GetAttrString(" << PYTHON_ARG << ", const_cast(\"" << revOpName << "\"));" << endl; + s << INDENT << "PyObject *revOpMethod = PyObject_GetAttrString(" << PYTHON_ARG << ", const_cast(\"" << revOpName << "\"));" << endl; s << INDENT << "if (revOpMethod && PyCallable_Check(revOpMethod)) {" << endl; { Indentation indent(INDENT); - s << INDENT << PYTHON_RETURN_VAR << " = PyObject_CallFunction(revOpMethod, const_cast(\"O\"), self);" << endl; + s << INDENT << PYTHON_RETURN_VAR << " = PyObject_CallFunction(revOpMethod, const_cast(\"O\"), self);" << endl; s << INDENT << "if (PyErr_Occurred() && (PyErr_ExceptionMatches(PyExc_NotImplementedError)"; s << " || PyErr_ExceptionMatches(PyExc_AttributeError))) {" << endl; { @@ -1927,16 +1927,16 @@ void CppGenerator::writeMethodWrapper(QTextStream &s, const AbstractMetaFunction s << '}' << endl << endl; } -void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overloadData) +void CppGenerator::writeArgumentsInitializer(QTextStream &s, OverloadData &overloadData) { - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); s << "PyTuple_GET_SIZE(args);" << endl; writeUnusedVariableCast(s, QLatin1String("numArgs")); int minArgs = overloadData.minArgs(); int maxArgs = overloadData.maxArgs(); - s << INDENT << "PyObject* "; + s << INDENT << "PyObject *"; s << PYTHON_ARGS << "[] = {" << QString(maxArgs, QLatin1Char('0')).split(QLatin1String(""), QString::SkipEmptyParts).join(QLatin1String(", ")) << "};" << endl; @@ -1947,7 +1947,7 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl if (minArgs > maxArgs) minArgs = maxArgs; - s << INDENT << "PyObject* nonvarargs = PyTuple_GetSlice(args, 0, " << maxArgs << ");" << endl; + s << INDENT << "PyObject *nonvarargs = PyTuple_GetSlice(args, 0, " << maxArgs << ");" << endl; s << INDENT << "Shiboken::AutoDecRef auto_nonvarargs(nonvarargs);" << endl; s << INDENT << PYTHON_ARGS << '[' << maxArgs << "] = PyTuple_GetSlice(args, " << maxArgs << ", numArgs);" << endl; s << INDENT << "Shiboken::AutoDecRef auto_varargs(" << PYTHON_ARGS << "[" << maxArgs << "]);" << endl; @@ -2025,10 +2025,10 @@ void CppGenerator::writeCppSelfAssigment(QTextStream &s, const GeneratorContext { static const QString pythonSelfVar = QLatin1String("self"); if (cppSelfAsReference) - s << className << "& "; + s << className << " &"; s << CPP_SELF_VAR << " = "; if (cppSelfAsReference) - s << '*'; + s << " *"; if (useWrapperClass) s << "static_cast<" << className << " *>("; if (!context.forSmartPointer()) @@ -2056,7 +2056,7 @@ void CppGenerator::writeCppSelfDefinition(QTextStream &s, } if (!cppSelfAsReference) { - s << INDENT << className << "* " << CPP_SELF_VAR << " = nullptr;" << endl; + s << INDENT << className << " *" << CPP_SELF_VAR << " = nullptr;" << endl; writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR)); } @@ -2103,9 +2103,9 @@ void CppGenerator::writeCppSelfDefinition(QTextStream &s, writeCppSelfDefinition(s, context, hasStaticOverload); } -void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData) +void CppGenerator::writeErrorSection(QTextStream &s, OverloadData &overloadData) { - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); s << endl << INDENT << cpythonFunctionName(rfunc) << "_TypeError:" << endl; Indentation indentation(INDENT); QString funcName = fullPythonFunctionName(rfunc); @@ -2116,7 +2116,7 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData) s << INDENT << "return " << m_currentErrorCode << ';' << endl; } -void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream& s, bool hasReturnValue) +void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream &s, bool hasReturnValue) { s << INDENT << "if (PyErr_Occurred()"; if (hasReturnValue) @@ -2131,14 +2131,14 @@ void CppGenerator::writeFunctionReturnErrorCheckSection(QTextStream& s, bool has s << INDENT << '}' << endl; } -void CppGenerator::writeInvalidPyObjectCheck(QTextStream& s, const QString& pyObj) +void CppGenerator::writeInvalidPyObjectCheck(QTextStream &s, const QString &pyObj) { s << INDENT << "if (!Shiboken::Object::isValid(" << pyObj << "))" << endl; Indentation indent(INDENT); s << INDENT << returnStatement(m_currentErrorCode) << endl; } -static QString pythonToCppConverterForArgumentName(const QString& argumentName) +static QString pythonToCppConverterForArgumentName(const QString &argumentName) { static const QRegularExpression pyArgsRegex(QLatin1String(PYTHON_ARGS) + QLatin1String(R"((\[\d+[-]?\d*\]))")); @@ -2150,11 +2150,11 @@ static QString pythonToCppConverterForArgumentName(const QString& argumentName) return result; } -void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber, QString customType, bool rejectNull) +void CppGenerator::writeTypeCheck(QTextStream &s, const AbstractMetaType *argType, QString argumentName, bool isNumber, QString customType, bool rejectNull) { QString customCheck; if (!customType.isEmpty()) { - AbstractMetaType* metaType; + AbstractMetaType *metaType; customCheck = guessCPythonCheckFunction(customType, &metaType); if (metaType) argType = metaType; @@ -2182,7 +2182,7 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const AbstractMetaType* argTyp s << typeCheck; } -static void checkTypeViability(const AbstractMetaFunction* func, const AbstractMetaType* type, int argIdx) +static void checkTypeViability(const AbstractMetaFunction *func, const AbstractMetaType *type, int argIdx) { if (!type || !type->typeEntry()->isPrimitive() @@ -2209,25 +2209,25 @@ static void checkTypeViability(const AbstractMetaFunction* func, const AbstractM qCWarning(lcShiboken).noquote().nospace() << message; } -static void checkTypeViability(const AbstractMetaFunction* func) +static void checkTypeViability(const AbstractMetaFunction *func) { if (func->isUserAdded()) return; - const AbstractMetaType* type = func->type(); + const AbstractMetaType *type = func->type(); checkTypeViability(func, type, 0); for (int i = 0; i < func->arguments().count(); ++i) checkTypeViability(func, func->arguments().at(i)->type(), i + 1); } -void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName) +void CppGenerator::writeTypeCheck(QTextStream &s, const OverloadData *overloadData, QString argumentName) { - QSet numericTypes; + QSet numericTypes; const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData(); for (OverloadData *od : overloads) { const OverloadData::MetaFunctionList &odOverloads = od->overloads(); for (const AbstractMetaFunction *func : odOverloads) { checkTypeViability(func); - const AbstractMetaType* argType = od->argument(func)->type(); + const AbstractMetaType *argType = od->argument(func)->type(); if (!argType->isPrimitive()) continue; if (ShibokenGenerator::isNumber(argType->typeEntry())) @@ -2237,18 +2237,18 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadDa // This condition trusts that the OverloadData object will arrange for // PyInt type to come after the more precise numeric types (e.g. float and bool) - const AbstractMetaType* argType = overloadData->argType(); + const AbstractMetaType *argType = overloadData->argType(); bool numberType = numericTypes.count() == 1 || ShibokenGenerator::isPyInt(argType); QString customType = (overloadData->hasArgumentTypeReplace() ? overloadData->argumentTypeReplaced() : QString()); bool rejectNull = shouldRejectNullPointerArgument(overloadData->referenceFunction(), overloadData->argPos()); writeTypeCheck(s, argType, argumentName, numberType, customType, rejectNull); } -void CppGenerator::writeArgumentConversion(QTextStream& s, - const AbstractMetaType* argType, - const QString& argName, const QString& pyArgName, - const AbstractMetaClass* context, - const QString& defaultValue, +void CppGenerator::writeArgumentConversion(QTextStream &s, + const AbstractMetaType *argType, + const QString &argName, const QString &pyArgName, + const AbstractMetaClass *context, + const QString &defaultValue, bool castArgumentAsUnused) { if (argType->typeEntry()->isCustom() || argType->typeEntry()->isVarargs()) @@ -2260,7 +2260,7 @@ void CppGenerator::writeArgumentConversion(QTextStream& s, writeUnusedVariableCast(s, argName); } -const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction* func, int argPos) +const AbstractMetaType *CppGenerator::getArgumentType(const AbstractMetaFunction *func, int argPos) { if (argPos < 0 || argPos > func->arguments().size()) { qCWarning(lcShiboken).noquote().nospace() @@ -2268,7 +2268,7 @@ const AbstractMetaType* CppGenerator::getArgumentType(const AbstractMetaFunction return 0; } - const AbstractMetaType* argType = 0; + const AbstractMetaType *argType = nullptr; QString typeReplaced = func->typeReplaced(argPos); if (typeReplaced.isEmpty()) argType = (argPos == 0) ? func->type() : func->arguments().at(argPos-1)->type(); @@ -2300,14 +2300,14 @@ static inline QString arrayHandleType(const AbstractMetaTypeCList &nestedArrayTy return QString(); } -void CppGenerator::writePythonToCppTypeConversion(QTextStream& s, - const AbstractMetaType* type, - const QString& pyIn, - const QString& cppOut, - const AbstractMetaClass* /* context */, - const QString& defaultValue) +void CppGenerator::writePythonToCppTypeConversion(QTextStream &s, + const AbstractMetaType *type, + const QString &pyIn, + const QString &cppOut, + const AbstractMetaClass * /* context */, + const QString &defaultValue) { - const TypeEntry* typeEntry = type->typeEntry(); + const TypeEntry *typeEntry = type->typeEntry(); if (typeEntry->isCustom() || typeEntry->isVarargs()) return; @@ -2336,7 +2336,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s, writeMinimalConstructorExpression(s, type, defaultValue); s << ';' << endl; } else if (avoidProtectedHack() && type->typeEntry()->isEnum()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(type); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(type); if (metaEnum && metaEnum->isProtected()) { typeName = QLatin1String("long"); isProtectedEnum = true; @@ -2347,11 +2347,11 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s, if (isCppPrimitiveArray) { s << ' ' << cppOut; } else if (treatAsPointer || isPointerOrObjectType) { - s << "* " << cppOut; + s << " *" << cppOut; if (!defaultValue.isEmpty()) s << " = " << defaultValue; } else if (type->referenceType() == LValueReference && !typeEntry->isPrimitive() && isNotContainerEnumOrFlags) { - s << "* " << cppOut << " = &" << cppOutAux; + s << " *" << cppOut << " = &" << cppOutAux; } else { s << ' ' << cppOut; if (isProtectedEnum && avoidProtectedHack()) { @@ -2400,7 +2400,7 @@ void CppGenerator::writePythonToCppTypeConversion(QTextStream& s, s << endl; } -static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rule, +static void addConversionRuleCodeSnippet(CodeSnipList &snippetList, QString &rule, TypeSystem::Language /* conversionLanguage */, TypeSystem::Language snippetLanguage, QString outputName = QString(), @@ -2420,7 +2420,7 @@ static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rul snippetList << snip; } -void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language) +void CppGenerator::writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language) { CodeSnipList snippets; const AbstractMetaArgumentList &arguments = func->arguments(); @@ -2432,7 +2432,7 @@ void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunctio writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionBeginning, TypeSystem::TargetLangCode, func); } -void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language, const QString& outputVar) +void CppGenerator::writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language, const QString &outputVar) { CodeSnipList snippets; QString rule = func->conversionRule(language, 0); @@ -2440,7 +2440,7 @@ void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunctio writeCodeSnips(s, snippets, TypeSystem::CodeSnipPositionAny, language, func); } -void CppGenerator::writeNoneReturn(QTextStream& s, const AbstractMetaFunction* func, bool thereIsReturnValue) +void CppGenerator::writeNoneReturn(QTextStream &s, const AbstractMetaFunction *func, bool thereIsReturnValue) { if (thereIsReturnValue && (!func->type() || func->argumentRemoved(0)) && !injectedCodeHasReturnValueAttribution(func)) { s << INDENT << PYTHON_RETURN_VAR << " = Py_None;" << endl; @@ -2448,10 +2448,10 @@ void CppGenerator::writeNoneReturn(QTextStream& s, const AbstractMetaFunction* f } } -void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const OverloadData& overloadData) +void CppGenerator::writeOverloadedFunctionDecisor(QTextStream &s, const OverloadData &overloadData) { s << INDENT << "// Overloaded function decisor" << endl; - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); const OverloadData::MetaFunctionList &functionOverloads = overloadData.overloadsWithoutRepetition(); for (int i = 0; i < functionOverloads.count(); i++) { const auto func = functionOverloads.at(i); @@ -2482,10 +2482,10 @@ void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const Overload s << endl; } -void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const OverloadData* parentOverloadData) +void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream &s, const OverloadData *parentOverloadData) { bool hasDefaultCall = parentOverloadData->nextArgumentHasDefaultValue(); - const AbstractMetaFunction* referenceFunction = parentOverloadData->referenceFunction(); + const AbstractMetaFunction *referenceFunction = parentOverloadData->referenceFunction(); // If the next argument has not an argument with a default value, it is still possible // that one of the overloads for the current overload data has its final occurrence here. @@ -2523,7 +2523,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov // The current overload data describes the last argument of a signature, // so the method can be identified right now. if (isLastArgument || (signatureFound && !hasDefaultCall)) { - const AbstractMetaFunction* func = parentOverloadData->referenceFunction(); + const AbstractMetaFunction *func = parentOverloadData->referenceFunction(); s << INDENT << "overloadId = " << parentOverloadData->headOverloadData()->overloads().indexOf(func); s << "; // " << func->minimalSignature() << endl; return; @@ -2542,9 +2542,9 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov s << INDENT << "if (numArgs == " << numArgs << ") {" << endl; { Indentation indent(INDENT); - const AbstractMetaFunction* func = referenceFunction; + const AbstractMetaFunction *func = referenceFunction; for (OverloadData *overloadData : overloads) { - const AbstractMetaFunction* defValFunc = overloadData->getFunctionWithDefaultValue(); + const AbstractMetaFunction *defValFunc = overloadData->getFunctionWithDefaultValue(); if (defValFunc) { func = defValFunc; break; @@ -2561,14 +2561,14 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov && !overloadData->getFunctionWithDefaultValue() && !overloadData->findNextArgWithDefault(); - const AbstractMetaFunction* refFunc = overloadData->referenceFunction(); + const AbstractMetaFunction *refFunc = overloadData->referenceFunction(); QStringList typeChecks; QString pyArgName = (usePyArgs && maxArgs > 1) ? pythonArgsAt(overloadData->argPos()) : QLatin1String(PYTHON_ARG); - OverloadData* od = overloadData; + OverloadData *od = overloadData; int startArg = od->argPos(); int sequenceArgCount = 0; while (od && !od->argType()->isVarargs()) { @@ -2578,11 +2578,11 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov pyArgName = pythonArgsAt(od->argPos()); QString typeCheck; QTextStream tck(&typeCheck); - const AbstractMetaFunction* func = od->referenceFunction(); + const AbstractMetaFunction *func = od->referenceFunction(); if (func->isConstructor() && func->arguments().count() == 1) { - const AbstractMetaClass* ownerClass = func->ownerClass(); - const ComplexTypeEntry* baseContainerType = ownerClass->typeEntry()->baseContainerType(); + const AbstractMetaClass *ownerClass = func->ownerClass(); + const ComplexTypeEntry *baseContainerType = ownerClass->typeEntry()->baseContainerType(); if (baseContainerType && baseContainerType == func->arguments().constFirst()->type()->typeEntry() && isCopyable(ownerClass)) { tck << '!' << cpythonCheckFunction(ownerClass->typeEntry()) << pyArgName << ')' << endl; Indentation indent(INDENT); @@ -2655,7 +2655,7 @@ void CppGenerator::writeFunctionCalls(QTextStream &s, const OverloadData &overlo writeSingleFunctionCall(s, overloadData, overloads.constFirst(), context); } else { for (int i = 0; i < overloads.count(); i++) { - const AbstractMetaFunction* func = overloads.at(i); + const AbstractMetaFunction *func = overloads.at(i); s << INDENT << "case " << i << ": // " << func->signature() << endl; s << INDENT << '{' << endl; { @@ -2705,7 +2705,7 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s, int removedArgs = 0; for (int argIdx = 0; argIdx < func->arguments().count(); ++argIdx) { bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, argIdx + 1).isEmpty(); - const AbstractMetaArgument* arg = func->arguments().at(argIdx); + const AbstractMetaArgument *arg = func->arguments().at(argIdx); if (func->argumentRemoved(argIdx + 1)) { if (!arg->defaultValueExpression().isEmpty()) { const QString cppArgRemoved = QLatin1String(CPP_ARG_REMOVED) @@ -2724,7 +2724,7 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s, } if (hasConversionRule) continue; - const AbstractMetaType* argType = getArgumentType(func, argIdx + 1); + const AbstractMetaType *argType = getArgumentType(func, argIdx + 1); if (!argType || (mayHaveUnunsedArguments && !injectedCodeUsesArgument(func, argIdx))) continue; int argPos = argIdx - removedArgs; @@ -2748,72 +2748,72 @@ void CppGenerator::writeSingleFunctionCall(QTextStream &s, s << INDENT << '}' << endl; } -QString CppGenerator::cppToPythonFunctionName(const QString& sourceTypeName, QString targetTypeName) +QString CppGenerator::cppToPythonFunctionName(const QString &sourceTypeName, QString targetTypeName) { if (targetTypeName.isEmpty()) targetTypeName = sourceTypeName; return QString::fromLatin1("%1_CppToPython_%2").arg(sourceTypeName, targetTypeName); } -QString CppGenerator::pythonToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName) +QString CppGenerator::pythonToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName) { return QString::fromLatin1("%1_PythonToCpp_%2").arg(sourceTypeName, targetTypeName); } -QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType) +QString CppGenerator::pythonToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType) { return pythonToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType)); } -QString CppGenerator::pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, - const TypeEntry* targetType) +QString CppGenerator::pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, + const TypeEntry *targetType) { return pythonToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType)); } -QString CppGenerator::convertibleToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName) +QString CppGenerator::convertibleToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName) { return QString::fromLatin1("is_%1_PythonToCpp_%2_Convertible").arg(sourceTypeName, targetTypeName); } -QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType) +QString CppGenerator::convertibleToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType) { return convertibleToCppFunctionName(fixedCppTypeName(sourceType), fixedCppTypeName(targetType)); } -QString CppGenerator::convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, - const TypeEntry* targetType) +QString CppGenerator::convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, + const TypeEntry *targetType) { return convertibleToCppFunctionName(fixedCppTypeName(toNative), fixedCppTypeName(targetType)); } -void CppGenerator::writeCppToPythonFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, QString targetTypeName) +void CppGenerator::writeCppToPythonFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, QString targetTypeName) { QString prettyCode; QTextStream c(&prettyCode); formatCode(c, code, INDENT); processCodeSnip(prettyCode); - s << "static PyObject* " << cppToPythonFunctionName(sourceTypeName, targetTypeName); - s << "(const void* cppIn) {" << endl; + s << "static PyObject *" << cppToPythonFunctionName(sourceTypeName, targetTypeName); + s << "(const void *cppIn) {" << endl; s << prettyCode; s << '}' << endl; } -static void replaceCppToPythonVariables(QString& code, const QString& typeName) +static void replaceCppToPythonVariables(QString &code, const QString &typeName) { code.prepend(QLatin1String("auto &cppInRef = *reinterpret_cast<") - + typeName + QLatin1String("*>(const_cast(cppIn));\n")); + + typeName + QLatin1String(" *>(const_cast(cppIn));\n")); code.replace(QLatin1String("%INTYPE"), typeName); - code.replace(QLatin1String("%OUTTYPE"), QLatin1String("PyObject*")); + code.replace(QLatin1String("%OUTTYPE"), QLatin1String("PyObject *")); code.replace(QLatin1String("%in"), QLatin1String("cppInRef")); code.replace(QLatin1String("%out"), QLatin1String("pyOut")); } -void CppGenerator::writeCppToPythonFunction(QTextStream& s, const CustomConversion* customConversion) +void CppGenerator::writeCppToPythonFunction(QTextStream &s, const CustomConversion *customConversion) { QString code = customConversion->nativeToTargetConversion(); replaceCppToPythonVariables(code, getFullTypeName(customConversion->ownerType())); writeCppToPythonFunction(s, code, fixedCppTypeName(customConversion->ownerType())); } -void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaType* containerType) +void CppGenerator::writeCppToPythonFunction(QTextStream &s, const AbstractMetaType *containerType) { - const CustomConversion* customConversion = containerType->typeEntry()->customConversion(); + const CustomConversion *customConversion = containerType->typeEntry()->customConversion(); if (!customConversion) { qFatal("Can't write the C++ to Python conversion function for container type '%s' - "\ "no conversion rule was defined for it in the type system.", @@ -2825,7 +2825,7 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy } QString code = customConversion->nativeToTargetConversion(); for (int i = 0; i < containerType->instantiations().count(); ++i) { - AbstractMetaType* type = containerType->instantiations().at(i); + AbstractMetaType *type = containerType->instantiations().at(i); QString typeName = getFullTypeName(type); if (type->isConstant()) typeName = QLatin1String("const ") + typeName; @@ -2836,22 +2836,22 @@ void CppGenerator::writeCppToPythonFunction(QTextStream& s, const AbstractMetaTy writeCppToPythonFunction(s, code, fixedCppTypeName(containerType)); } -void CppGenerator::writePythonToCppFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, const QString& targetTypeName) +void CppGenerator::writePythonToCppFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, const QString &targetTypeName) { QString prettyCode; QTextStream c(&prettyCode); formatCode(c, code, INDENT); processCodeSnip(prettyCode); s << "static void " << pythonToCppFunctionName(sourceTypeName, targetTypeName); - s << "(PyObject* pyIn, void* cppOut) {" << endl; + s << "(PyObject *pyIn, void *cppOut) {" << endl; s << prettyCode; s << '}' << endl; } -void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s, - const QString& sourceTypeName, - const QString& targetTypeName, - const QString& condition, +void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream &s, + const QString &sourceTypeName, + const QString &targetTypeName, + const QString &condition, QString pythonToCppFuncName, bool acceptNoneAsCppNull) { @@ -2859,7 +2859,7 @@ void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s, pythonToCppFuncName = pythonToCppFunctionName(sourceTypeName, targetTypeName); s << "static PythonToCppFunc " << convertibleToCppFunctionName(sourceTypeName, targetTypeName); - s << "(PyObject* pyIn) {" << endl; + s << "(PyObject *pyIn) {" << endl; if (acceptNoneAsCppNull) { s << INDENT << "if (pyIn == Py_None)" << endl; Indentation indent(INDENT); @@ -2874,9 +2874,9 @@ void CppGenerator::writeIsPythonConvertibleToCppFunction(QTextStream& s, s << '}' << endl; } -void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, - const AbstractMetaType* sourceType, - const AbstractMetaType* targetType, +void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s, + const AbstractMetaType *sourceType, + const AbstractMetaType *targetType, QString typeCheck, QString conversion, QString preConversion) @@ -2891,7 +2891,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, if (!preConversion.isEmpty()) c << INDENT << preConversion << endl; const QString fullTypeName = getFullTypeName(targetType->typeEntry()); - c << INDENT << "*reinterpret_cast<" << fullTypeName << "*>(cppOut) = " + c << INDENT << "*reinterpret_cast<" << fullTypeName << " *>(cppOut) = " << fullTypeName << '(' << conversion << ");"; QString sourceTypeName = fixedCppTypeName(sourceType); QString targetTypeName = fixedCppTypeName(targetType); @@ -2904,9 +2904,9 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, s << endl; } -void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, - const CustomConversion::TargetToNativeConversion* toNative, - const TypeEntry* targetType) +void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s, + const CustomConversion::TargetToNativeConversion *toNative, + const TypeEntry *targetType) { // Python to C++ conversion function. QString code = toNative->conversion(); @@ -2919,7 +2919,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, code.replace(QLatin1String("%OUTTYPE"), targetType->qualifiedCppName()); code.replace(QLatin1String("%in"), QLatin1String("pyIn")); code.replace(QLatin1String("%out"), - QLatin1String("*reinterpret_cast<") + getFullTypeName(targetType) + QLatin1String("*>(cppOut)")); + QLatin1String("*reinterpret_cast<") + getFullTypeName(targetType) + QLatin1String(" *>(cppOut)")); QString sourceTypeName = fixedCppTypeName(toNative); QString targetTypeName = fixedCppTypeName(targetType); @@ -2956,14 +2956,14 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, writeIsPythonConvertibleToCppFunction(s, sourceTypeName, targetTypeName, typeCheck); } -void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const AbstractMetaType* containerType) +void CppGenerator::writePythonToCppConversionFunctions(QTextStream &s, const AbstractMetaType *containerType) { - const CustomConversion* customConversion = containerType->typeEntry()->customConversion(); + const CustomConversion *customConversion = containerType->typeEntry()->customConversion(); if (!customConversion) { //qFatal return; } - const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions(); + const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions(); if (toCppConversions.isEmpty()) { //qFatal return; @@ -2973,10 +2973,10 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs QString code; QTextStream c(&code); c << INDENT << "auto &cppOutRef = *reinterpret_cast<" - << cppTypeName << "*>(cppOut);\n"; + << cppTypeName << " *>(cppOut);\n"; code.append(toCppConversions.constFirst()->conversion()); for (int i = 0; i < containerType->instantiations().count(); ++i) { - const AbstractMetaType* type = containerType->instantiations().at(i); + const AbstractMetaType *type = containerType->instantiations().at(i); QString typeName = getFullTypeName(type); if (type->isValue() && isValueTypeWithCopyConstructorOnly(type)) { for (int pos = 0; ; ) { @@ -2989,7 +2989,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs rightCode.replace(varName, QLatin1Char('*') + varName); code.replace(pos, code.size() - pos, rightCode); } - typeName.append(QLatin1Char('*')); + typeName.append(QLatin1String(" *")); } code.replace(QString::fromLatin1("%OUTTYPE_%1").arg(i), typeName); } @@ -3009,7 +3009,7 @@ void CppGenerator::writePythonToCppConversionFunctions(QTextStream& s, const Abs s << endl; } -void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString& converterVar, const QString& pythonToCppFunc, const QString& isConvertibleFunc) +void CppGenerator::writeAddPythonToCppConversion(QTextStream &s, const QString &converterVar, const QString &pythonToCppFunc, const QString &isConvertibleFunc) { s << INDENT << "Shiboken::Conversions::addPythonToCppValueConversion(" << converterVar << ',' << endl; { @@ -3020,7 +3020,7 @@ void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString& s << ");" << endl; } -void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs) +void CppGenerator::writeNamedArgumentResolution(QTextStream &s, const AbstractMetaFunction *func, bool usePyArgs) { const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func); if (args.isEmpty()) @@ -3032,7 +3032,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe s << INDENT << "if (kwds) {" << endl; { Indentation indent(INDENT); - s << INDENT << "PyObject* "; + s << INDENT << "PyObject *"; for (const AbstractMetaArgument *arg : args) { int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex()); QString pyArgName = usePyArgs ? pythonArgsAt(pyArgIndex) : QLatin1String(PYTHON_ARG); @@ -3063,7 +3063,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe s << INDENT << '}' << endl; } -QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, int argIndex, const AbstractMetaClass** wrappedClass) +QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex, const AbstractMetaClass **wrappedClass) { *wrappedClass = 0; QString pyArgName; @@ -3086,7 +3086,7 @@ QString CppGenerator::argumentNameFromIndex(const AbstractMetaFunction* func, in } } else { int realIndex = argIndex - 1 - OverloadData::numberOfRemovedArguments(func, argIndex - 1); - AbstractMetaType* argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type()); + AbstractMetaType *argType = getTypeWithoutContainer(func->arguments().at(realIndex)->type()); if (argType) { *wrappedClass = AbstractMetaClass::findClass(classes(), argType->typeEntry()); @@ -3120,14 +3120,14 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f const CodeSnipList &snips = func->injectedCodeSnips(); for (const CodeSnip &cs : snips) { if (cs.position == TypeSystem::CodeSnipPositionEnd) { - s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast(func)) << ';' << endl; + s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast(func)) << ';' << endl; break; } } } if (func->isAbstract()) { - s << INDENT << "if (Shiboken::Object::hasCppWrapper(reinterpret_cast(self))) {\n"; + s << INDENT << "if (Shiboken::Object::hasCppWrapper(reinterpret_cast(self))) {\n"; { Indentation indent(INDENT); s << INDENT << "PyErr_SetString(PyExc_NotImplementedError, \"pure virtual method '"; @@ -3138,7 +3138,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f } // Used to provide contextual information to custom code writer function. - const AbstractMetaArgument* lastArg = 0; + const AbstractMetaArgument *lastArg = nullptr; CodeSnipList snips; if (func->hasInjectedCode()) { @@ -3169,7 +3169,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f if (func->functionType() != AbstractMetaFunction::CopyConstructorFunction) { int removedArgs = 0; for (int i = 0; i < maxArgs + removedArgs; i++) { - const AbstractMetaArgument* arg = func->arguments().at(i); + const AbstractMetaArgument *arg = func->arguments().at(i); bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty(); if (func->argumentRemoved(i + 1)) { // If some argument with default value is removed from a @@ -3207,7 +3207,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f bool otherArgsModified = false; bool argsClear = true; for (int i = func->arguments().size() - 1; i >= maxArgs + removedArgs; i--) { - const AbstractMetaArgument* arg = func->arguments().at(i); + const AbstractMetaArgument *arg = func->arguments().at(i); const bool defValModified = arg->hasModifiedDefaultValueExpression(); bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty(); if (argsClear && !defValModified && !hasConversionRule) @@ -3269,7 +3269,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f } else { QString ctorCall = className + QLatin1Char('(') + userArgs.join(QLatin1String(", ")) + QLatin1Char(')'); if (usePySideExtensions() && func->ownerClass()->isQObject()) { - s << INDENT << "void* addr = PySide::nextQObjectMemoryAddr();" << endl; + s << INDENT << "void *addr = PySide::nextQObjectMemoryAddr();" << endl; uva << "if (addr) {" << endl; { Indentation indent(INDENT); @@ -3318,15 +3318,15 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f : QLatin1String("reinterpret_cast<") + wrapperName(func->ownerClass()) + QLatin1String(" *>(") + QLatin1String(CPP_SELF_VAR) + QLatin1Char(')'); mc << wrapperName(func->ownerClass()); - mc << "*>(" << selfWrapCast << ")->"; + mc << " *>(" << selfWrapCast << ")->"; } else { mc << methodCallClassName; - mc << "*>(" << selfVarCast << ")->"; + mc << " *>(" << selfVarCast << ")->"; } } else { mc << "const_cast(" << selfVarCast << ")->"; + mc << " *>(" << selfVarCast << ")->"; } } else { mc << selfVarCast << "->"; @@ -3342,7 +3342,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f const auto *owner = func->ownerClass(); const bool directInheritance = context.metaClass() == owner; mc << (directInheritance ? "static_cast" : "reinterpret_cast") - << "<::" << wrapperName(owner) << "*>(" << CPP_SELF_VAR << ")->"; + << "<::" << wrapperName(owner) << " *>(" << CPP_SELF_VAR << ")->"; } if (!func->isAbstract()) @@ -3364,7 +3364,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f methodCallClassName); normalCall.remove(QLatin1String("::%CLASS_NAME::")); methodCall.clear(); - mc << "Shiboken::Object::hasCppWrapper(reinterpret_cast(self)) ? "; + mc << "Shiboken::Object::hasCppWrapper(reinterpret_cast(self)) ? "; mc << virtualCall << " : " << normalCall; } } @@ -3391,7 +3391,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f } else if (func->type() && !func->isInplaceOperator()) { bool writeReturnType = true; if (avoidProtectedHack()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(func->type()); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(func->type()); if (metaEnum) { QString enumName; if (metaEnum->isProtected()) @@ -3475,7 +3475,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f if (!ownership_mods.isEmpty()) { s << endl << INDENT << "// Ownership transferences." << endl; for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) { - const AbstractMetaClass* wrappedClass = 0; + const AbstractMetaClass *wrappedClass = nullptr; QString pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass); if (!wrappedClass) { s << "#error Invalid ownership modification for argument " << arg_mod.index << '(' << pyArgName << ')' << endl << endl; @@ -3513,7 +3513,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f qCWarning(lcShiboken) << "\"set\", \"add\" and \"remove\" are the only values supported by Shiboken for action attribute of reference-count tag."; continue; } - const AbstractMetaClass* wrappedClass = 0; + const AbstractMetaClass *wrappedClass = nullptr; QString pyArgName; if (refCount.action == ReferenceCount::Remove) { @@ -3531,7 +3531,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f else s << INDENT << "Shiboken::Object::removeReference("; - s << "reinterpret_cast(self), \""; + s << "reinterpret_cast(self), \""; QString varName = arg_mod.referenceCounts.constFirst().varName; if (varName.isEmpty()) varName = func->minimalSignature() + QString::number(arg_mod.index); @@ -3547,7 +3547,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f writeParentChildManagement(s, func, !hasReturnPolicy); } -QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass* metaClass) +QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass *metaClass) { QStringList result; const AbstractMetaClassList &baseClases = getBaseClasses(metaClass); @@ -3555,13 +3555,13 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass for (const AbstractMetaClass *baseClass : baseClases) { QString offset; QTextStream(&offset) << "reinterpret_cast(static_castqualifiedCppName() << "*>(class_ptr)) - base"; + << baseClass->qualifiedCppName() << " *>(class_ptr)) - base"; result.append(offset); offset.clear(); QTextStream(&offset) << "reinterpret_cast(static_castqualifiedCppName() << "*>(static_castqualifiedCppName() << " *>(static_castqualifiedCppName() - << "*>(static_cast(class_ptr)))) - base"; + << " *>(static_cast(class_ptr)))) - base"; result.append(offset); } @@ -3571,7 +3571,7 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass return result; } -void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream &s, const AbstractMetaClass *metaClass) { QString className = metaClass->qualifiedCppName(); const QStringList ancestors = getAncestorMultipleInheritance(metaClass); @@ -3579,14 +3579,14 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c for (int i = 0; i < ancestors.size(); i++) s << "-1, "; s << "-1 };" << endl; - s << "int*" << endl; - s << multipleInheritanceInitializerFunctionName(metaClass) << "(const void* cptr)" << endl; + s << "int *" << endl; + s << multipleInheritanceInitializerFunctionName(metaClass) << "(const void *cptr)" << endl; s << '{' << endl; s << INDENT << "if (mi_offsets[0] == -1) {" << endl; { Indentation indent(INDENT); s << INDENT << "std::set offsets;" << endl; - s << INDENT << "const auto* class_ptr = reinterpret_cast(cptr);" << endl; + s << INDENT << "const auto *class_ptr = reinterpret_cast(cptr);" << endl; s << INDENT << "const auto base = reinterpret_cast(class_ptr);" << endl; for (const QString &ancestor : ancestors) @@ -3603,27 +3603,27 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c s << '}' << endl; } -void CppGenerator::writeSpecialCastFunction(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeSpecialCastFunction(QTextStream &s, const AbstractMetaClass *metaClass) { QString className = metaClass->qualifiedCppName(); - s << "static void* " << cpythonSpecialCastFunctionName(metaClass) << "(void* obj, SbkObjectType* desiredType)\n"; + s << "static void * " << cpythonSpecialCastFunctionName(metaClass) << "(void *obj, SbkObjectType *desiredType)\n"; s << "{\n"; - s << INDENT << className << "* me = reinterpret_cast< ::" << className << "*>(obj);\n"; + s << INDENT << "auto me = reinterpret_cast< ::" << className << " *>(obj);\n"; bool firstClass = true; const AbstractMetaClassList &allAncestors = getAllAncestors(metaClass); for (const AbstractMetaClass *baseClass : allAncestors) { - s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n"; + s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n"; Indentation indent(INDENT); - s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << "*>(me);\n"; + s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << " *>(me);\n"; firstClass = false; } s << INDENT << "return me;\n"; s << "}\n\n"; } -void CppGenerator::writePrimitiveConverterInitialization(QTextStream& s, const CustomConversion* customConversion) +void CppGenerator::writePrimitiveConverterInitialization(QTextStream &s, const CustomConversion *customConversion) { - const TypeEntry* type = customConversion->ownerType(); + const TypeEntry *type = customConversion->ownerType(); QString converter = converterObject(type); s << INDENT << "// Register converter for type '" << type->qualifiedTargetLangName() << "'." << endl; s << INDENT << converter << " = Shiboken::Conversions::createConverter("; @@ -3639,30 +3639,30 @@ void CppGenerator::writePrimitiveConverterInitialization(QTextStream& s, const C writeCustomConverterRegister(s, customConversion, converter); } -void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum) +void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum) { if (metaEnum->isPrivate() || metaEnum->isAnonymous()) return; writeEnumConverterInitialization(s, metaEnum->typeEntry()); } -void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType) +void CppGenerator::writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType) { if (!enumType) return; QString enumFlagName = enumType->isFlags() ? QLatin1String("flag") : QLatin1String("enum"); QString enumPythonType = cpythonTypeNameExt(enumType); - const FlagsTypeEntry* flags = 0; + const FlagsTypeEntry *flags = nullptr; if (enumType->isFlags()) - flags = static_cast(enumType); + flags = static_cast(enumType); s << INDENT << "// Register converter for " << enumFlagName << " '" << enumType->qualifiedCppName() << "'." << endl; s << INDENT << '{' << endl; { Indentation indent(INDENT); QString typeName = fixedCppTypeName(enumType); - s << INDENT << "SbkConverter* converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << endl; + s << INDENT << "SbkConverter *converter = Shiboken::Conversions::createConverter(" << enumPythonType << ',' << endl; { Indentation indent(INDENT); s << INDENT << cppToPythonFunctionName(typeName, typeName) << ");" << endl; @@ -3714,10 +3714,10 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn s << INDENT << '}' << endl; if (!flags) - writeEnumConverterInitialization(s, static_cast(enumType)->flags()); + writeEnumConverterInitialization(s, static_cast(enumType)->flags()); } -void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type) +void CppGenerator::writeContainerConverterInitialization(QTextStream &s, const AbstractMetaType *type) { QByteArray cppSignature = QMetaObject::normalizedSignature(type->cppSignature().toUtf8()); s << INDENT << "// Register converter for type '" << cppSignature << "'." << endl; @@ -3744,8 +3744,8 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A writeAddPythonToCppConversion(s, converterObject(type), toCpp, isConv); } -void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, - const QVector& conversions) +void CppGenerator::writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType, + const QVector& conversions) { s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl; for (const AbstractMetaClass *sourceClass : conversions) { @@ -3760,14 +3760,14 @@ void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const Ty } } -QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass* metaClass) +QString CppGenerator::multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("_mi_init"); } typedef QHash >::const_iterator ProtocolIt; -bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass* metaClass) +bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass *metaClass) { for (ProtocolIt it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) { if (metaClass->hasFunction(it.key())) @@ -3777,7 +3777,7 @@ bool CppGenerator::supportsMappingProtocol(const AbstractMetaClass* metaClass) return false; } -bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass* metaClass) +bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass *metaClass) { return metaClass->hasArithmeticOperatorOverload() || metaClass->hasLogicalOperatorOverload() @@ -3785,18 +3785,18 @@ bool CppGenerator::supportsNumberProtocol(const AbstractMetaClass* metaClass) || hasBoolCast(metaClass); } -bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass* metaClass) +bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass *metaClass) { for (ProtocolIt it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) { if (metaClass->hasFunction(it.key())) return true; } - const ComplexTypeEntry* baseType = metaClass->typeEntry()->baseContainerType(); + const ComplexTypeEntry *baseType = metaClass->typeEntry()->baseContainerType(); return baseType && baseType->isContainer(); } -bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass* metaClass) +bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass *metaClass) { const AbstractMetaFieldList &fields = metaClass->fields(); for (const AbstractMetaField *f : fields) { @@ -3824,7 +3824,7 @@ QTextStream &operator<<(QTextStream &str, const pyTypeSlotEntry &e) if (e.m_function.isEmpty()) str << NULL_PTR; else - str << "reinterpret_cast(" << e.m_function << ')'; + str << "reinterpret_cast(" << e.m_function << ')'; str << "},\n"; return str; } @@ -3850,7 +3850,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s, } if (!metaClass->baseClass()) - baseClassName = QLatin1String("reinterpret_cast(SbkObject_TypeF())"); + baseClassName = QLatin1String("reinterpret_cast(SbkObject_TypeF())"); bool onlyPrivCtor = !metaClass->hasNonPrivateConstructor(); @@ -3937,7 +3937,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s, } // class or some ancestor has multiple inheritance - const AbstractMetaClass* miClass = getMultipleInheritingClass(metaClass); + const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass); if (miClass) { if (metaClass == miClass) writeMultipleInheritanceInitializerFunction(s, metaClass); @@ -3951,7 +3951,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s, if (!metaClass->typeEntry()->hashFunction().isEmpty()) tp_hash = QLatin1Char('&') + cpythonBaseName(metaClass) + QLatin1String("_HashFunc"); - const AbstractMetaFunction* callOp = metaClass->findFunction(QLatin1String("operator()")); + const AbstractMetaFunction *callOp = metaClass->findFunction(QLatin1String("operator()")); if (callOp && !callOp->isModifiedRemoved()) tp_call = QLatin1Char('&') + cpythonFunctionName(callOp); @@ -3963,7 +3963,7 @@ void CppGenerator::writeClassDefinition(QTextStream &s, QString suffix; if (isObjectType(metaClass)) - suffix = QLatin1String("*"); + suffix = QLatin1String(" *"); const QString typePtr = QLatin1String("_") + className + QLatin1String("_Type"); s << "static SbkObjectType *" << typePtr << " = nullptr;" << endl; @@ -4021,7 +4021,7 @@ void CppGenerator::writeMappingMethods(QTextStream &s, GeneratorContext &context) { for (auto it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) { - const AbstractMetaFunction* func = metaClass->findFunction(it.key()); + const AbstractMetaFunction *func = metaClass->findFunction(it.key()); if (!func) continue; QString funcName = cpythonFunctionName(func); @@ -4034,7 +4034,7 @@ void CppGenerator::writeMappingMethods(QTextStream &s, writeCppSelfDefinition(s, func, context); - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? nullptr : func->arguments().constLast(); writeCodeSnips(s, snips, TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg); s << '}' << endl << endl; } @@ -4047,7 +4047,7 @@ void CppGenerator::writeSequenceMethods(QTextStream &s, bool injectedCode = false; for (auto it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) { - const AbstractMetaFunction* func = metaClass->findFunction(it.key()); + const AbstractMetaFunction *func = metaClass->findFunction(it.key()); if (!func) continue; injectedCode = true; @@ -4061,7 +4061,7 @@ void CppGenerator::writeSequenceMethods(QTextStream &s, writeCppSelfDefinition(s, func, context); - const AbstractMetaArgument* lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); + const AbstractMetaArgument *lastArg = func->arguments().isEmpty() ? 0 : func->arguments().constLast(); writeCodeSnips(s, snips,TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode, func, lastArg); s << '}' << endl << endl; } @@ -4070,13 +4070,13 @@ void CppGenerator::writeSequenceMethods(QTextStream &s, writeStdListWrapperMethods(s, context); } -void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTypeAsSequenceDefinition(QTextStream &s, const AbstractMetaClass *metaClass) { bool hasFunctions = false; QMap funcs; for (ProtocolIt it = m_sequenceProtocol.cbegin(), end = m_sequenceProtocol.cend(); it != end; ++it) { const QString &funcName = it.key(); - const AbstractMetaFunction* func = metaClass->findFunction(funcName); + const AbstractMetaFunction *func = metaClass->findFunction(funcName); funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QString(); if (!hasFunctions && func) hasFunctions = true; @@ -4092,7 +4092,7 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM } for (QHash::const_iterator it = m_sqFuncs.cbegin(), end = m_sqFuncs.cend(); it != end; ++it) { - const QString& sqName = it.key(); + const QString &sqName = it.key(); if (funcs[sqName].isEmpty()) continue; if (it.value() == QLatin1String("sq_slice")) @@ -4103,13 +4103,13 @@ void CppGenerator::writeTypeAsSequenceDefinition(QTextStream& s, const AbstractM } } -void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTypeAsMappingDefinition(QTextStream &s, const AbstractMetaClass *metaClass) { bool hasFunctions = false; QMap funcs; for (ProtocolIt it = m_mappingProtocol.cbegin(), end = m_mappingProtocol.cend(); it != end; ++it) { const QString &funcName = it.key(); - const AbstractMetaFunction* func = metaClass->findFunction(funcName); + const AbstractMetaFunction *func = metaClass->findFunction(funcName); funcs[funcName] = func ? cpythonFunctionName(func).prepend(QLatin1Char('&')) : QLatin1String("0"); if (!hasFunctions && func) hasFunctions = true; @@ -4130,7 +4130,7 @@ void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMe } } -void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTypeAsNumberDefinition(QTextStream &s, const AbstractMetaClass *metaClass) { QMap nb; @@ -4165,7 +4165,7 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet | AbstractMetaClass::BitwiseOp); for (const AbstractMetaFunctionList &opOverload : opOverloads) { - const AbstractMetaFunction* rfunc = opOverload[0]; + const AbstractMetaFunction *rfunc = opOverload.at(0); QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc); nb[opName] = cpythonFunctionName(rfunc); } @@ -4208,21 +4208,21 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet } } -void CppGenerator::writeTpTraverseFunction(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTpTraverseFunction(QTextStream &s, const AbstractMetaClass *metaClass) { QString baseName = cpythonBaseName(metaClass); s << "static int "; - s << baseName << "_traverse(PyObject* self, visitproc visit, void* arg)" << endl; + s << baseName << "_traverse(PyObject *self, visitproc visit, void *arg)" << endl; s << '{' << endl; s << INDENT << "return reinterpret_cast(SbkObject_TypeF())->tp_traverse(self, visit, arg);" << endl; s << '}' << endl; } -void CppGenerator::writeTpClearFunction(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTpClearFunction(QTextStream &s, const AbstractMetaClass *metaClass) { QString baseName = cpythonBaseName(metaClass); s << "static int "; - s << baseName << "_clear(PyObject* self)" << endl; + s << baseName << "_clear(PyObject *self)" << endl; s << '{' << endl; s << INDENT << "return reinterpret_cast(SbkObject_TypeF())->tp_clear(self);" << endl; s << '}' << endl; @@ -4232,7 +4232,7 @@ void CppGenerator::writeCopyFunction(QTextStream &s, GeneratorContext &context) { const AbstractMetaClass *metaClass = context.metaClass(); const QString className = chopType(cpythonTypeName(metaClass)); - s << "static PyObject* " << className << "___copy__(PyObject* self)" << endl; + s << "static PyObject *" << className << "___copy__(PyObject *self)" << endl; s << "{" << endl; writeCppSelfDefinition(s, context, false, true); QString conversionCode; @@ -4241,7 +4241,7 @@ void CppGenerator::writeCopyFunction(QTextStream &s, GeneratorContext &context) else conversionCode = cpythonToPythonConversionFunction(context.preciseType()); - s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << " = " << conversionCode; + s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << " = " << conversionCode; s << CPP_SELF_VAR << ");" << endl; writeFunctionReturnErrorCheckSection(s); s << INDENT << "return " << PYTHON_RETURN_VAR << ";" << endl; @@ -4254,19 +4254,19 @@ void CppGenerator::writeGetterFunction(QTextStream &s, GeneratorContext &context) { ErrorCode errorCode(QString::fromLatin1(NULL_PTR)); - s << "static PyObject* " << cpythonGetterFunctionName(metaField) << "(PyObject* self, void*)" << endl; + s << "static PyObject *" << cpythonGetterFunctionName(metaField) << "(PyObject *self, void *)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); - AbstractMetaType* fieldType = metaField->type(); + AbstractMetaType *fieldType = metaField->type(); // Force use of pointer to return internal variable memory bool newWrapperSameObject = !fieldType->isConstant() && isWrapperType(fieldType) && !isPointer(fieldType); QString cppField; if (avoidProtectedHack() && metaField->isProtected()) { QTextStream(&cppField) << "static_cast<" - << wrapperName(metaField->enclosingClass()) << "*>(" + << wrapperName(metaField->enclosingClass()) << " *>(" << CPP_SELF_VAR << ")->" << protectedFieldGetterName(metaField) << "()"; } else { cppField = QLatin1String(CPP_SELF_VAR) + QLatin1String("->") + metaField->name(); @@ -4281,16 +4281,16 @@ void CppGenerator::writeGetterFunction(QTextStream &s, } else if (avoidProtectedHack() && metaField->isProtected()) { s << INDENT << getFullTypeNameWithoutModifiers(fieldType); if (fieldType->isContainer() || fieldType->isFlags() || fieldType->isSmartPointer()) { - s << '&'; + s << " &"; cppField.prepend(QLatin1Char('*')); } else if ((!fieldType->isConstant() && !fieldType->isEnum() && !fieldType->isPrimitive()) || fieldType->indirections() == 1) { - s << '*'; + s << " *"; } s << " fieldValue = " << cppField << ';' << endl; cppField = QLatin1String("fieldValue"); } - s << INDENT << "PyObject* pyOut = {};\n"; + s << INDENT << "PyObject *pyOut = {};\n"; if (newWrapperSameObject) { // Special case colocated field with same address (first field in a struct) s << INDENT << "if (reinterpret_cast(" @@ -4310,7 +4310,7 @@ void CppGenerator::writeGetterFunction(QTextStream &s, s << INDENT << "else if (Shiboken::BindingManager::instance().hasWrapper(" << cppField << ")) {" << "\n"; { Indentation indent(INDENT); - s << INDENT << "pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(" + s << INDENT << "pyOut = reinterpret_cast(Shiboken::BindingManager::instance().retrieveWrapper(" << cppField << "));" << "\n"; s << INDENT << "Py_IncRef(pyOut);" << "\n"; s << INDENT << "return pyOut;" << "\n"; @@ -4336,7 +4336,7 @@ void CppGenerator::writeSetterFunction(QTextStream &s, GeneratorContext &context) { ErrorCode errorCode(0); - s << "static int " << cpythonSetterFunctionName(metaField) << "(PyObject* self, PyObject* pyIn, void*)" << endl; + s << "static int " << cpythonSetterFunctionName(metaField) << "(PyObject *self, PyObject *pyIn, void *)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); @@ -4350,7 +4350,7 @@ void CppGenerator::writeSetterFunction(QTextStream &s, } s << INDENT << '}' << endl; - AbstractMetaType* fieldType = metaField->type(); + AbstractMetaType *fieldType = metaField->type(); s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << "{nullptr};" << endl; s << INDENT << "if (!"; @@ -4368,10 +4368,10 @@ void CppGenerator::writeSetterFunction(QTextStream &s, s << INDENT; if (avoidProtectedHack() && metaField->isProtected()) { s << getFullTypeNameWithoutModifiers(fieldType); - s << (fieldType->indirections() == 1 ? "*" : "") << " cppOut;" << endl; + s << (fieldType->indirections() == 1 ? " *" : "") << " cppOut;" << endl; s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut);" << endl; s << INDENT << "static_cast<" << wrapperName(metaField->enclosingClass()) - << "*>(" << CPP_SELF_VAR << ")->" << protectedFieldSetterName(metaField) + << " *>(" << CPP_SELF_VAR << ")->" << protectedFieldSetterName(metaField) << "(cppOut)"; } else if (isCppIntegralPrimitive(fieldType) || fieldType->typeEntry()->isEnum() || fieldType->typeEntry()->isFlags()) { s << getFullTypeNameWithoutModifiers(fieldType) << " cppOut_local = " << cppField << ';' << endl; @@ -4381,14 +4381,14 @@ void CppGenerator::writeSetterFunction(QTextStream &s, if (isPointerToConst(fieldType)) s << "const "; s << getFullTypeNameWithoutModifiers(fieldType); - s << QString::fromLatin1("*").repeated(fieldType->indirections()) << "& cppOut_ptr = "; + s << QString::fromLatin1(" *").repeated(fieldType->indirections()) << "& cppOut_ptr = "; s << cppField << ';' << endl; s << INDENT << PYTHON_TO_CPP_VAR << "(pyIn, &cppOut_ptr)"; } s << ';' << endl << endl; if (isPointerToWrapperType(fieldType)) { - s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast(self), \""; + s << INDENT << "Shiboken::Object::keepReference(reinterpret_cast(self), \""; s << metaField->name() << "\", pyIn);" << endl; } @@ -4400,12 +4400,12 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co { const AbstractMetaClass *metaClass = context.metaClass(); QString baseName = cpythonBaseName(metaClass); - s << "static PyObject* "; - s << baseName << "_richcompare(PyObject* self, PyObject* " << PYTHON_ARG << ", int op)" << endl; + s << "static PyObject * "; + s << baseName << "_richcompare(PyObject *self, PyObject *" << PYTHON_ARG << ", int op)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context, false, true); writeUnusedVariableCast(s, QLatin1String(CPP_SELF_VAR)); - s << INDENT << "PyObject* " << PYTHON_RETURN_VAR << "{};" << endl; + s << INDENT << "PyObject *" << PYTHON_RETURN_VAR << "{};" << endl; s << INDENT << "PythonToCppFunc " << PYTHON_TO_CPP_VAR << ';' << endl; writeUnusedVariableCast(s, QLatin1String(PYTHON_TO_CPP_VAR)); s << endl; @@ -4415,7 +4415,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co Indentation indent(INDENT); const QVector &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp); for (const AbstractMetaFunctionList &overloads : groupedFuncs) { - const AbstractMetaFunction* rfunc = overloads[0]; + const AbstractMetaFunction *rfunc = overloads[0]; QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc); s << INDENT << "case " << operatorId << ':' << endl; @@ -4436,10 +4436,10 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co OverloadData overloadData(overloads, this); const OverloadDataList &nextOverloads = overloadData.nextOverloadData(); for (OverloadData *od : nextOverloads) { - const AbstractMetaFunction* func = od->referenceFunction(); + const AbstractMetaFunction *func = od->referenceFunction(); if (func->isStatic()) continue; - const AbstractMetaType* argType = getArgumentType(func, 1); + const AbstractMetaType *argType = getArgumentType(func, 1); if (!argType) continue; if (!first) { @@ -4517,12 +4517,12 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co s << '}' << endl << endl; } -void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads) +void CppGenerator::writeMethodDefinitionEntry(QTextStream &s, const AbstractMetaFunctionList &overloads) { Q_ASSERT(!overloads.isEmpty()); OverloadData overloadData(overloads, this); bool usePyArgs = pythonFunctionWrapperUsesListOfArguments(overloadData); - const AbstractMetaFunction* func = overloadData.referenceFunction(); + const AbstractMetaFunction *func = overloadData.referenceFunction(); int min = overloadData.minArgs(); int max = overloadData.maxArgs(); @@ -4542,10 +4542,10 @@ void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMeta s << "|METH_STATIC"; } -void CppGenerator::writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads) +void CppGenerator::writeMethodDefinition(QTextStream &s, const AbstractMetaFunctionList &overloads) { Q_ASSERT(!overloads.isEmpty()); - const AbstractMetaFunction* func = overloads.constFirst(); + const AbstractMetaFunction *func = overloads.constFirst(); if (m_tpFuncs.contains(func->name())) return; @@ -4566,7 +4566,7 @@ static QString resolveRetOrArgType(const AbstractMetaType *someType) if (CppGenerator::isCString(someType)) { strRetArg = QLatin1String("str"); } else if (someType->isPrimitive()) { - const PrimitiveTypeEntry* ptp = static_cast(someType->typeEntry()); + auto ptp = static_cast(someType->typeEntry()); while (ptp->referencedTypeEntry()) ptp = ptp->referencedTypeEntry(); strRetArg = ptp->name(); @@ -4580,7 +4580,7 @@ static QString resolveRetOrArgType(const AbstractMetaType *someType) void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads) { OverloadData overloadData(overloads, this); - const AbstractMetaFunction* rfunc = overloadData.referenceFunction(); + const AbstractMetaFunction *rfunc = overloadData.referenceFunction(); QString funcName = fullPythonFunctionName(rfunc); int idx = overloads.length() - 1; @@ -4619,7 +4619,7 @@ void CppGenerator::writeSignatureInfo(QTextStream &s, const AbstractMetaFunction } } -void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList& enums) +void CppGenerator::writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList &enums) { if (enums.isEmpty()) return; @@ -4631,10 +4631,10 @@ void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList } } -void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnum* cppEnum) +void CppGenerator::writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *cppEnum) { - const AbstractMetaClass* enclosingClass = getProperEnclosingClassForEnum(cppEnum); - const AbstractMetaClass* upper = enclosingClass ? enclosingClass->enclosingClass() : 0; + const AbstractMetaClass *enclosingClass = getProperEnclosingClassForEnum(cppEnum); + const AbstractMetaClass *upper = enclosingClass ? enclosingClass->enclosingClass() : nullptr; bool hasUpperEnclosingClass = upper && upper->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass; const EnumTypeEntry *enumTypeEntry = cppEnum->typeEntry(); QString enclosingObjectVariable; @@ -4651,7 +4651,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu QString enumVarTypeObj; if (!cppEnum->isAnonymous()) { - FlagsTypeEntry* flags = enumTypeEntry->flags(); + FlagsTypeEntry *flags = enumTypeEntry->flags(); if (flags) { // The following could probably be made nicer: // We need 'flags->flagsName()' with the full module/class path. @@ -4708,7 +4708,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu s << INDENT << '{' << endl; { Indentation indent(INDENT); - s << INDENT << "PyObject* anonEnumItem = PyInt_FromLong(" << enumValueText << ");" << endl; + s << INDENT << "PyObject *anonEnumItem = PyInt_FromLong(" << enumValueText << ");" << endl; s << INDENT << "if (PyDict_SetItemString(reinterpret_cast(reinterpret_cast(" << enclosingObjectVariable << "))->tp_dict, \"" << enumValue->name() << "\", anonEnumItem) < 0)" << endl; { @@ -4757,7 +4757,7 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu s << '.' << endl << endl; } -void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass) { // Try to check something and print some warnings const AbstractMetaFunctionList &signalFuncs = metaClass->cppSignalFunctions(); @@ -4766,7 +4766,7 @@ void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaC continue; const AbstractMetaArgumentList &arguments = cppSignal->arguments(); for (AbstractMetaArgument *arg : arguments) { - AbstractMetaType* metaType = arg->type(); + AbstractMetaType *metaType = arg->type(); const QByteArray origType = QMetaObject::normalizedType(qPrintable(metaType->originalTypeDescription())); const QByteArray cppSig = @@ -4783,36 +4783,36 @@ void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaC << metaClass->qualifiedCppName() << "::staticMetaObject);" << endl; } -void CppGenerator::writeFlagsToLong(QTextStream& s, const AbstractMetaEnum* cppEnum) +void CppGenerator::writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum) { - FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags(); + FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags(); if (!flagsEntry) return; - s << "static PyObject* " << cpythonEnumName(cppEnum) << "_long(PyObject* self)" << endl; + s << "static PyObject *" << cpythonEnumName(cppEnum) << "_long(PyObject *self)" << endl; s << "{" << endl; s << INDENT << "int val;" << endl; - AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); + AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &val);" << endl; s << INDENT << "return Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &val);" << endl; s << "}" << endl; } -void CppGenerator::writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cppEnum) +void CppGenerator::writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum) { - FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags(); + FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags(); if (!flagsEntry) return; - s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject* self)" << endl; + s << "static int " << cpythonEnumName(cppEnum) << "__nonzero(PyObject *self)" << endl; s << "{" << endl; s << INDENT << "int val;" << endl; - AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); + AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &val);" << endl; s << INDENT << "return val != 0;" << endl; s << "}" << endl; } -void CppGenerator::writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum) +void CppGenerator::writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum) { writeFlagsBinaryOperator(s, cppEnum, QLatin1String("and"), QLatin1String("&")); writeFlagsBinaryOperator(s, cppEnum, QLatin1String("or"), QLatin1String("|")); @@ -4825,7 +4825,7 @@ void CppGenerator::writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cpp s << endl; } -void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum) +void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum) { QString cpythonName = cpythonEnumName(cppEnum); @@ -4848,16 +4848,16 @@ void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream& s, const Abstr s << "};" << endl << endl; } -void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum, +void CppGenerator::writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum, const QString &pyOpName, const QString &cppOpName) { - FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags(); + FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags(); Q_ASSERT(flagsEntry); - s << "PyObject* " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject* self, PyObject* " << PYTHON_ARG << ")" << endl; + s << "PyObject * " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")" << endl; s << '{' << endl; - AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); + AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); s << INDENT << "::" << flagsEntry->originalName() << " cppResult, " << CPP_SELF_VAR << ", cppArg;" << endl; s << "#ifdef IS_PY3K" << endl; s << INDENT << CPP_SELF_VAR << " = static_cast<::" << flagsEntry->originalName() @@ -4877,17 +4877,17 @@ void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEn s << '}' << endl << endl; } -void CppGenerator::writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum, +void CppGenerator::writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum, const QString &pyOpName, const QString &cppOpName, bool boolResult) { - FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags(); + FlagsTypeEntry *flagsEntry = cppEnum->typeEntry()->flags(); Q_ASSERT(flagsEntry); - s << "PyObject* " << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject* self, PyObject* " << PYTHON_ARG << ")" << endl; + s << "PyObject *" << cpythonEnumName(cppEnum) << "___" << pyOpName << "__(PyObject *self, PyObject *" << PYTHON_ARG << ")" << endl; s << '{' << endl; - AbstractMetaType* flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); + AbstractMetaType *flagsType = buildAbstractMetaTypeFromTypeEntry(flagsEntry); s << INDENT << "::" << flagsEntry->originalName() << " " << CPP_SELF_VAR << ";" << endl; s << INDENT << cpythonToCppConversionFunction(flagsType) << "self, &" << CPP_SELF_VAR << ");" << endl; s << INDENT; @@ -4928,9 +4928,9 @@ void CppGenerator::writeClassRegister(QTextStream &s, GeneratorContext &classContext, QTextStream &signatureStream) { - const ComplexTypeEntry* classTypeEntry = metaClass->typeEntry(); + const ComplexTypeEntry *classTypeEntry = metaClass->typeEntry(); - const AbstractMetaClass* enc = metaClass->enclosingClass(); + const AbstractMetaClass *enc = metaClass->enclosingClass(); bool hasEnclosingClass = enc && enc->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass; QString enclosingObjectVariable = hasEnclosingClass ? QLatin1String("enclosingClass") : QLatin1String("module"); @@ -4946,20 +4946,20 @@ void CppGenerator::writeClassRegister(QTextStream &s, s << INDENT << '"' << line << "\"," << endl; s << INDENT << NULL_PTR << "}; // Sentinel" << endl << endl; s << "void init_" << initFunctionName; - s << "(PyObject* " << enclosingObjectVariable << ")" << endl; + s << "(PyObject *" << enclosingObjectVariable << ")" << endl; s << '{' << endl; // Multiple inheritance QString pyTypeBasesVariable = chopType(pyTypeName) + QLatin1String("_Type_bases"); const AbstractMetaClassList baseClasses = getBaseClasses(metaClass); if (metaClass->baseClassNames().size() > 1) { - s << INDENT << "PyObject* " << pyTypeBasesVariable + s << INDENT << "PyObject *" << pyTypeBasesVariable << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl; Indentation indent(INDENT); for (int i = 0, size = baseClasses.size(); i < size; ++i) { if (i) s << "," << endl; - s << INDENT << "reinterpret_cast(" + s << INDENT << "reinterpret_cast(" << cpythonTypeNameExt(baseClasses.at(i)->typeEntry()) << ')'; } s << ");" << endl << endl; @@ -5048,7 +5048,7 @@ void CppGenerator::writeClassRegister(QTextStream &s, s << INDENT << cpythonTypeNameExt(classTypeEntry) << endl; else s << INDENT << cpythonTypeNameExt(classContext.preciseType()) << endl; - s << INDENT << " = reinterpret_cast(" << pyTypeName << ");" << endl; + s << INDENT << " = reinterpret_cast(" << pyTypeName << ");" << endl; s << endl; // Register conversions for the type. @@ -5062,13 +5062,13 @@ void CppGenerator::writeClassRegister(QTextStream &s, } // Fill multiple inheritance data, if needed. - const AbstractMetaClass* miClass = getMultipleInheritingClass(metaClass); + const AbstractMetaClass *miClass = getMultipleInheritingClass(metaClass); if (miClass) { s << INDENT << "MultipleInheritanceInitFunction func = "; if (miClass == metaClass) { s << multipleInheritanceInitializerFunctionName(miClass) << ";" << endl; } else { - s << "Shiboken::ObjectType::getMultipleInheritanceFunction(reinterpret_cast("; + s << "Shiboken::ObjectType::getMultipleInheritanceFunction(reinterpret_cast("; s << cpythonTypeNameExt(miClass->typeEntry()) << "));" << endl; } s << INDENT << "Shiboken::ObjectType::setMultipleInheritanceFunction("; @@ -5130,7 +5130,7 @@ void CppGenerator::writeClassRegister(QTextStream &s, void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorContext &context) const { - const AbstractMetaClass* metaClass = context.metaClass(); + const AbstractMetaClass *metaClass = context.metaClass(); // Gets all class name variants used on different possible scopes QStringList nameVariants; if (!context.forSmartPointer()) @@ -5138,7 +5138,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont else nameVariants << context.preciseType()->cppSignature(); - const AbstractMetaClass* enclosingClass = metaClass->enclosingClass(); + const AbstractMetaClass *enclosingClass = metaClass->enclosingClass(); while (enclosingClass) { if (enclosingClass->typeEntry()->generateCode()) nameVariants << (enclosingClass->name() + QLatin1String("::") + nameVariants.constLast()); @@ -5194,17 +5194,17 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont } } -void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMetaClass* metaClass) +void CppGenerator::writeTypeDiscoveryFunction(QTextStream &s, const AbstractMetaClass *metaClass) { QString polymorphicExpr = metaClass->typeEntry()->polymorphicIdValue(); - s << "static void* " << cpythonBaseName(metaClass) << "_typeDiscovery(void* cptr, SbkObjectType* instanceType)\n{" << endl; + s << "static void *" << cpythonBaseName(metaClass) << "_typeDiscovery(void *cptr, SbkObjectType *instanceType)\n{" << endl; if (!polymorphicExpr.isEmpty()) { polymorphicExpr = polymorphicExpr.replace(QLatin1String("%1"), QLatin1String(" reinterpret_cast< ::") + metaClass->qualifiedCppName() - + QLatin1String("*>(cptr)")); + + QLatin1String(" *>(cptr)")); s << INDENT << " if (" << polymorphicExpr << ")" << endl; { Indentation indent(INDENT); @@ -5216,11 +5216,11 @@ void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMeta if (ancestor->baseClass()) continue; if (ancestor->isPolymorphic()) { - s << INDENT << "if (instanceType == reinterpret_cast(Shiboken::SbkType< ::" + s << INDENT << "if (instanceType == reinterpret_cast(Shiboken::SbkType< ::" << ancestor->qualifiedCppName() << " >()))" << endl; Indentation indent(INDENT); s << INDENT << "return dynamic_cast< ::" << metaClass->qualifiedCppName() - << "*>(reinterpret_cast< ::"<< ancestor->qualifiedCppName() << "*>(cptr));" << endl; + << " *>(reinterpret_cast< ::"<< ancestor->qualifiedCppName() << " *>(cptr));" << endl; } else { qCWarning(lcShiboken).noquote().nospace() << metaClass->qualifiedCppName() << " inherits from a non polymorphic type (" @@ -5242,14 +5242,14 @@ QString CppGenerator::writeSmartPointerGetterCast() void CppGenerator::writeSetattroFunction(QTextStream &s, GeneratorContext &context) { - const AbstractMetaClass* metaClass = context.metaClass(); - s << "static int " << cpythonSetattroFunctionName(metaClass) << "(PyObject* self, PyObject* name, PyObject* value)" << endl; + const AbstractMetaClass *metaClass = context.metaClass(); + s << "static int " << cpythonSetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name, PyObject *value)" << endl; s << '{' << endl; if (usePySideExtensions()) { - s << INDENT << "Shiboken::AutoDecRef pp(reinterpret_cast(PySide::Property::getObject(self, name)));" << endl; + s << INDENT << "Shiboken::AutoDecRef pp(reinterpret_cast(PySide::Property::getObject(self, name)));" << endl; s << INDENT << "if (!pp.isNull())" << endl; Indentation indent(INDENT); - s << INDENT << "return PySide::Property::setValue(reinterpret_cast(pp.object()), self, value);" << endl; + s << INDENT << "return PySide::Property::setValue(reinterpret_cast(pp.object()), self, value);" << endl; } if (context.forSmartPointer()) { @@ -5279,10 +5279,10 @@ void CppGenerator::writeSetattroFunction(QTextStream &s, GeneratorContext &conte static inline QString qObjectClassName() { return QStringLiteral("QObject"); } static inline QString qMetaObjectClassName() { return QStringLiteral("QMetaObject"); } -void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &context) +void CppGenerator::writeGetattroFunction(QTextStream &s, GeneratorContext &context) { - const AbstractMetaClass* metaClass = context.metaClass(); - s << "static PyObject* " << cpythonGetattroFunctionName(metaClass) << "(PyObject* self, PyObject* name)" << endl; + const AbstractMetaClass *metaClass = context.metaClass(); + s << "static PyObject *" << cpythonGetattroFunctionName(metaClass) << "(PyObject *self, PyObject *name)" << endl; s << '{' << endl; QString getattrFunc; @@ -5301,10 +5301,10 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &conte { Indentation indent(INDENT); s << INDENT << "// Search the method in the instance dict" << endl; - s << INDENT << "if (reinterpret_cast(self)->ob_dict) {" << endl; + s << INDENT << "if (reinterpret_cast(self)->ob_dict) {" << endl; { Indentation indent(INDENT); - s << INDENT << "PyObject* meth = PyDict_GetItem(reinterpret_cast(self)->ob_dict, name);" << endl; + s << INDENT << "PyObject *meth = PyDict_GetItem(reinterpret_cast(self)->ob_dict, name);" << endl; s << INDENT << "if (meth) {" << endl; { Indentation indent(INDENT); @@ -5463,7 +5463,7 @@ bool CppGenerator::finishGeneration() const QString initFunctionName = QLatin1String("init_") + getSimpleClassInitFunctionName(cls); - s_classInitDecl << "void " << initFunctionName << "(PyObject* module);" << endl; + s_classInitDecl << "void " << initFunctionName << "(PyObject *module);" << endl; s_classPythonDefines << INDENT << initFunctionName; if (cls->enclosingClass() @@ -5481,7 +5481,7 @@ bool CppGenerator::finishGeneration() for (const AbstractMetaType *metaType : smartPtrs) { GeneratorContext context(0, metaType, true); QString initFunctionName = getInitFunctionName(context); - s_classInitDecl << "void init_" << initFunctionName << "(PyObject* module);" << endl; + s_classInitDecl << "void init_" << initFunctionName << "(PyObject *module);" << endl; QString defineStr = QLatin1String("init_") + initFunctionName; defineStr += QLatin1String("(module);"); s_classPythonDefines << INDENT << defineStr << endl; @@ -5518,13 +5518,13 @@ bool CppGenerator::finishGeneration() AbstractMetaEnumList globalEnums = this->globalEnums(); const AbstractMetaClassList &classList = classes(); for (const AbstractMetaClass *metaClass : classList) { - const AbstractMetaClass* encClass = metaClass->enclosingClass(); + const AbstractMetaClass *encClass = metaClass->enclosingClass(); if (encClass && encClass->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass) continue; lookForEnumsInClassesNotToBeGenerated(globalEnums, metaClass); } - TypeDatabase* typeDb = TypeDatabase::instance(); + TypeDatabase *typeDb = TypeDatabase::instance(); const TypeSystemTypeEntry *moduleEntry = typeDb->defaultTypeSystemType(); Q_ASSERT(moduleEntry); @@ -5539,13 +5539,13 @@ bool CppGenerator::finishGeneration() s << endl; s << "// Current module's type array." << endl; - s << "PyTypeObject** " << cppApiVariableName() << " = nullptr;" << endl; + s << "PyTypeObject **" << cppApiVariableName() << " = nullptr;" << endl; s << "// Current module's PyObject pointer." << endl; - s << "PyObject* " << pythonModuleObjectName() << " = nullptr;" << endl; + s << "PyObject *" << pythonModuleObjectName() << " = nullptr;" << endl; s << "// Current module's converter array." << endl; - s << "SbkConverter** " << convertersVariableName() << " = nullptr;" << endl; + s << "SbkConverter **" << convertersVariableName() << " = nullptr;" << endl; const CodeSnipList snips = moduleEntry->codeSnips(); @@ -5563,7 +5563,7 @@ bool CppGenerator::finishGeneration() s << INDENT << "for (int i = 0, imax = SBK_" << moduleName() << "_IDX_COUNT; i < imax; i++) {" << endl; { Indentation indentation(INDENT); - s << INDENT << "PyObject *pyType = reinterpret_cast(" << cppApiVariableName() << "[i]);" << endl; + s << INDENT << "PyObject *pyType = reinterpret_cast(" << cppApiVariableName() << "[i]);" << endl; s << INDENT << "if (pyType && PyObject_HasAttrString(pyType, \"staticMetaObject\"))"<< endl; { Indentation indentation(INDENT); @@ -5612,8 +5612,8 @@ bool CppGenerator::finishGeneration() if (!requiredModules.isEmpty()) s << "// Required modules' type and converter arrays." << endl; for (const QString &requiredModule : requiredModules) { - s << "PyTypeObject** " << cppApiVariableName(requiredModule) << ';' << endl; - s << "SbkConverter** " << convertersVariableName(requiredModule) << ';' << endl; + s << "PyTypeObject **" << cppApiVariableName(requiredModule) << ';' << endl; + s << "SbkConverter **" << convertersVariableName(requiredModule) << ';' << endl; } s << endl; @@ -5626,8 +5626,8 @@ bool CppGenerator::finishGeneration() const TypeEntry *externalType = it.key(); s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl; for (const AbstractMetaClass *sourceClass : it.value()) { - AbstractMetaType* sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass); - AbstractMetaType* targetType = buildAbstractMetaTypeFromTypeEntry(externalType); + AbstractMetaType *sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass); + AbstractMetaType *targetType = buildAbstractMetaTypeFromTypeEntry(externalType); writePythonToCppConversionFunctions(s, sourceType, targetType); } } @@ -5694,7 +5694,7 @@ bool CppGenerator::finishGeneration() s << endl; } - for (const QString& requiredModule : requiredModules) { + for (const QString &requiredModule : requiredModules) { s << INDENT << "{" << endl; { Indentation indentation(INDENT); @@ -5713,18 +5713,18 @@ bool CppGenerator::finishGeneration() int maxTypeIndex = getMaxTypeIndex() + instantiatedSmartPointers().size(); if (maxTypeIndex) { s << INDENT << "// Create an array of wrapper types for the current module." << endl; - s << INDENT << "static PyTypeObject* cppApi[SBK_" << moduleName() << "_IDX_COUNT];" << endl; + s << INDENT << "static PyTypeObject *cppApi[SBK_" << moduleName() << "_IDX_COUNT];" << endl; s << INDENT << cppApiVariableName() << " = cppApi;" << endl << endl; } s << INDENT << "// Create an array of primitive type converters for the current module." << endl; - s << INDENT << "static SbkConverter* sbkConverters[SBK_" << moduleName() << "_CONVERTERS_IDX_COUNT" << "];" << endl; + s << INDENT << "static SbkConverter *sbkConverters[SBK_" << moduleName() << "_CONVERTERS_IDX_COUNT" << "];" << endl; s << INDENT << convertersVariableName() << " = sbkConverters;" << endl << endl; s << "#ifdef IS_PY3K" << endl; - s << INDENT << "PyObject* module = Shiboken::Module::create(\"" << moduleName() << "\", &moduledef);" << endl; + s << INDENT << "PyObject *module = Shiboken::Module::create(\"" << moduleName() << "\", &moduledef);" << endl; s << "#else" << endl; - s << INDENT << "PyObject* module = Shiboken::Module::create(\"" << moduleName() << "\", "; + s << INDENT << "PyObject *module = Shiboken::Module::create(\"" << moduleName() << "\", "; s << moduleName() << "_methods);" << endl; s << "#endif" << endl << endl; @@ -5829,7 +5829,7 @@ bool CppGenerator::finishGeneration() return file.done() != FileOut::Failure; } -static ArgumentOwner getArgumentOwner(const AbstractMetaFunction* func, int argIndex) +static ArgumentOwner getArgumentOwner(const AbstractMetaFunction *func, int argIndex) { ArgumentOwner argOwner = func->argumentOwner(func->ownerClass(), argIndex); if (argOwner.index == ArgumentOwner::InvalidIndex) @@ -5837,7 +5837,7 @@ static ArgumentOwner getArgumentOwner(const AbstractMetaFunction* func, int argI return argOwner; } -bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool useHeuristicPolicy) +bool CppGenerator::writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, int argIndex, bool useHeuristicPolicy) { const int numArgs = func->arguments().count(); bool ctorHeuristicEnabled = func->isConstructor() && useCtorHeuristic() && useHeuristicPolicy; @@ -5852,7 +5852,7 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta int parentIndex = argOwner.index; int childIndex = argIndex; if (ctorHeuristicEnabled && argIndex > 0 && numArgs) { - AbstractMetaArgument* arg = func->arguments().at(argIndex-1); + AbstractMetaArgument *arg = func->arguments().at(argIndex-1); if (arg->name() == QLatin1String("parent") && isObjectType(arg->type())) { action = ArgumentOwner::Add; parentIndex = argIndex; @@ -5896,7 +5896,7 @@ bool CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta return false; } -void CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool useHeuristicForReturn) +void CppGenerator::writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, bool useHeuristicForReturn) { const int numArgs = func->arguments().count(); @@ -5910,7 +5910,7 @@ void CppGenerator::writeParentChildManagement(QTextStream& s, const AbstractMeta writeReturnValueHeuristics(s, func); } -void CppGenerator::writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self) +void CppGenerator::writeReturnValueHeuristics(QTextStream &s, const AbstractMetaFunction *func, const QString &self) { AbstractMetaType *type = func->type(); if (!useReturnValueHeuristic() @@ -5932,7 +5932,7 @@ void CppGenerator::writeReturnValueHeuristics(QTextStream& s, const AbstractMeta void CppGenerator::writeHashFunction(QTextStream &s, GeneratorContext &context) { const AbstractMetaClass *metaClass = context.metaClass(); - s << "static Py_hash_t " << cpythonBaseName(metaClass) << "_HashFunc(PyObject* self) {" << endl; + s << "static Py_hash_t " << cpythonBaseName(metaClass) << "_HashFunc(PyObject *self) {" << endl; writeCppSelfDefinition(s, context); s << INDENT << "return " << metaClass->typeEntry()->hashFunction() << '('; s << (isObjectType(metaClass) ? "" : "*") << CPP_SELF_VAR << ");" << endl; @@ -5945,14 +5945,14 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext & ErrorCode errorCode(0); // __len__ - s << "Py_ssize_t " << cpythonBaseName(metaClass->typeEntry()) << "__len__(PyObject* self)" << endl; + s << "Py_ssize_t " << cpythonBaseName(metaClass->typeEntry()) << "__len__(PyObject *self)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); s << INDENT << "return " << CPP_SELF_VAR << "->size();" << endl; s << '}' << endl; // __getitem__ - s << "PyObject* " << cpythonBaseName(metaClass->typeEntry()) << "__getitem__(PyObject* self, Py_ssize_t _i)" << endl; + s << "PyObject *" << cpythonBaseName(metaClass->typeEntry()) << "__getitem__(PyObject *self, Py_ssize_t _i)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); writeIndexError(s, QLatin1String("index out of bounds")); @@ -5960,7 +5960,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext & s << INDENT << metaClass->qualifiedCppName() << "::iterator _item = " << CPP_SELF_VAR << "->begin();" << endl; s << INDENT << "for (Py_ssize_t pos = 0; pos < _i; pos++) _item++;" << endl; - const AbstractMetaType* itemType = metaClass->templateBaseClassInstantiations().constFirst(); + const AbstractMetaType *itemType = metaClass->templateBaseClassInstantiations().constFirst(); s << INDENT << "return "; writeToPythonConversion(s, itemType, metaClass, QLatin1String("*_item")); @@ -5969,7 +5969,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext & // __setitem__ ErrorCode errorCode2(-1); - s << "int " << cpythonBaseName(metaClass->typeEntry()) << "__setitem__(PyObject* self, Py_ssize_t _i, PyObject* pyArg)" << endl; + s << "int " << cpythonBaseName(metaClass->typeEntry()) << "__setitem__(PyObject *self, Py_ssize_t _i, PyObject *pyArg)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); writeIndexError(s, QLatin1String("list assignment index out of range")); @@ -5993,7 +5993,7 @@ void CppGenerator::writeStdListWrapperMethods(QTextStream &s, GeneratorContext & s << INDENT << "return {};" << endl; s << '}' << endl; } -void CppGenerator::writeIndexError(QTextStream& s, const QString& errorMsg) +void CppGenerator::writeIndexError(QTextStream &s, const QString &errorMsg) { s << INDENT << "if (_i < 0 || _i >= (Py_ssize_t) " << CPP_SELF_VAR << "->size()) {" << endl; { @@ -6010,7 +6010,7 @@ QString CppGenerator::writeReprFunction(QTextStream &s, GeneratorContext &contex QString funcName = cpythonBaseName(metaClass) + QLatin1String("__repr__"); s << "extern \"C\"" << endl; s << '{' << endl; - s << "static PyObject* " << funcName << "(PyObject* self)" << endl; + s << "static PyObject *" << funcName << "(PyObject *self)" << endl; s << '{' << endl; writeCppSelfDefinition(s, context); s << INDENT << "QBuffer buffer;" << endl; @@ -6028,7 +6028,7 @@ QString CppGenerator::writeReprFunction(QTextStream &s, GeneratorContext &contex Indentation indent(INDENT); s << INDENT << "str.replace(0, idx, Py_TYPE(self)->tp_name);" << endl; } - s << INDENT << "PyObject* mod = PyDict_GetItemString(Py_TYPE(self)->tp_dict, \"__module__\");" << endl; + s << INDENT << "PyObject *mod = PyDict_GetItemString(Py_TYPE(self)->tp_dict, \"__module__\");" << endl; // PYSIDE-595: The introduction of heap types has the side effect that the module name // is always prepended to the type name. Therefore the strchr check: s << INDENT << "if (mod && !strchr(str, '.'))" << endl; diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.h b/sources/shiboken2/generator/shiboken2/cppgenerator.h index 519e12b7b..44a04653a 100644 --- a/sources/shiboken2/generator/shiboken2/cppgenerator.h +++ b/sources/shiboken2/generator/shiboken2/cppgenerator.h @@ -44,38 +44,38 @@ public: protected: QString fileNameSuffix() const override; QString fileNameForContext(GeneratorContext &context) const override; - QVector filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass, + QVector filterGroupedOperatorFunctions(const AbstractMetaClass *metaClass, uint query); - void generateClass(QTextStream& s, GeneratorContext &classContext) override; + void generateClass(QTextStream &s, GeneratorContext &classContext) override; bool finishGeneration() override; private: - void writeConstructorNative(QTextStream& s, const AbstractMetaFunction* func); - void writeDestructorNative(QTextStream& s, const AbstractMetaClass* metaClass); + void writeConstructorNative(QTextStream &s, const AbstractMetaFunction *func); + void writeDestructorNative(QTextStream &s, const AbstractMetaClass *metaClass); - QString getVirtualFunctionReturnTypeName(const AbstractMetaFunction* func); - void writeVirtualMethodNative(QTextStream& s, const AbstractMetaFunction* func); + QString getVirtualFunctionReturnTypeName(const AbstractMetaFunction *func); + void writeVirtualMethodNative(QTextStream &s, const AbstractMetaFunction *func); - void writeMetaObjectMethod(QTextStream& s, const AbstractMetaClass* metaClass); - void writeMetaCast(QTextStream& s, const AbstractMetaClass* metaClass); + void writeMetaObjectMethod(QTextStream &s, const AbstractMetaClass *metaClass); + void writeMetaCast(QTextStream &s, const AbstractMetaClass *metaClass); - void writeEnumConverterFunctions(QTextStream& s, const TypeEntry* enumType); - void writeEnumConverterFunctions(QTextStream& s, const AbstractMetaEnum* metaEnum); + void writeEnumConverterFunctions(QTextStream &s, const TypeEntry *enumType); + void writeEnumConverterFunctions(QTextStream &s, const AbstractMetaEnum *metaEnum); void writeConverterFunctions(QTextStream &s, const AbstractMetaClass *metaClass, GeneratorContext &classContext); - void writeCustomConverterFunctions(QTextStream& s, const CustomConversion* customConversion); + void writeCustomConverterFunctions(QTextStream &s, const CustomConversion *customConversion); void writeConverterRegister(QTextStream &s, const AbstractMetaClass *metaClass, GeneratorContext &classContext); - void writeCustomConverterRegister(QTextStream& s, const CustomConversion* customConversion, const QString& converterVar); + void writeCustomConverterRegister(QTextStream &s, const CustomConversion *customConversion, const QString &converterVar); - void writeContainerConverterFunctions(QTextStream& s, const AbstractMetaType* containerType); + void writeContainerConverterFunctions(QTextStream &s, const AbstractMetaType *containerType); void writeMethodWrapperPreamble(QTextStream &s, OverloadData &overloadData, GeneratorContext &context); void writeConstructorWrapper(QTextStream &s, const AbstractMetaFunctionList overloads, GeneratorContext &classContext); void writeMethodWrapper(QTextStream &s, const AbstractMetaFunctionList overloads, GeneratorContext &classContext); - void writeArgumentsInitializer(QTextStream& s, OverloadData& overloadData); + void writeArgumentsInitializer(QTextStream &s, OverloadData &overloadData); void writeCppSelfAssigment(QTextStream &s, const GeneratorContext &context, const QString &className, bool cppSelfAsReference, bool useWrapperClass); @@ -88,16 +88,16 @@ private: bool hasStaticOverload = false, bool cppSelfAsReference = false); - void writeErrorSection(QTextStream& s, OverloadData& overloadData); - void writeFunctionReturnErrorCheckSection(QTextStream& s, bool hasReturnValue = true); + void writeErrorSection(QTextStream &s, OverloadData &overloadData); + void writeFunctionReturnErrorCheckSection(QTextStream &s, bool hasReturnValue = true); /// Writes the check section for the validity of wrapped C++ objects. - void writeInvalidPyObjectCheck(QTextStream& s, const QString& pyObj); + void writeInvalidPyObjectCheck(QTextStream &s, const QString &pyObj); - void writeTypeCheck(QTextStream& s, const AbstractMetaType* argType, QString argumentName, bool isNumber = false, QString customType = QString(), bool rejectNull = false); - void writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName); + void writeTypeCheck(QTextStream &s, const AbstractMetaType *argType, QString argumentName, bool isNumber = false, QString customType = QString(), bool rejectNull = false); + void writeTypeCheck(QTextStream &s, const OverloadData *overloadData, QString argumentName); - void writeTypeDiscoveryFunction(QTextStream& s, const AbstractMetaClass* metaClass); + void writeTypeDiscoveryFunction(QTextStream &s, const AbstractMetaClass *metaClass); void writeSetattroFunction(QTextStream &s, GeneratorContext &context); void writeGetattroFunction(QTextStream &s, GeneratorContext &context); @@ -115,10 +115,10 @@ private: * \param defaultValue an optional default value to be used instead of the conversion result * \param castArgumentAsUnused if true the converted argument is cast as unused to avoid compiler warnings */ - void writeArgumentConversion(QTextStream& s, const AbstractMetaType* argType, - const QString& argName, const QString& pyArgName, - const AbstractMetaClass* context = 0, - const QString& defaultValue = QString(), + void writeArgumentConversion(QTextStream &s, const AbstractMetaType *argType, + const QString &argName, const QString &pyArgName, + const AbstractMetaClass *context = 0, + const QString &defaultValue = QString(), bool castArgumentAsUnused = false); /** @@ -132,19 +132,19 @@ private: * \param newType It is set to true if the type returned is a new object that must be deallocated. * \return The type of the argument indicated by \p argPos. */ - const AbstractMetaType* getArgumentType(const AbstractMetaFunction* func, int argPos); + const AbstractMetaType *getArgumentType(const AbstractMetaFunction *func, int argPos); - void writePythonToCppTypeConversion(QTextStream& s, - const AbstractMetaType* type, - const QString& pyIn, - const QString& cppOut, - const AbstractMetaClass* context = 0, - const QString& defaultValue = QString()); + void writePythonToCppTypeConversion(QTextStream &s, + const AbstractMetaType *type, + const QString &pyIn, + const QString &cppOut, + const AbstractMetaClass *context = 0, + const QString &defaultValue = QString()); /// Writes the conversion rule for arguments of regular and virtual methods. - void writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language); + void writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language); /// Writes the conversion rule for the return value of a method. - void writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language, const QString& outputVar); + void writeConversionRule(QTextStream &s, const AbstractMetaFunction *func, TypeSystem::Language language, const QString &outputVar); /** * Set the Python method wrapper return value variable to Py_None if @@ -155,7 +155,7 @@ private: * \param thereIsReturnValue indicates if the return type of any of the other overloads * for this function is different from 'void' */ - void writeNoneReturn(QTextStream& s, const AbstractMetaFunction* func, bool thereIsReturnValue); + void writeNoneReturn(QTextStream &s, const AbstractMetaFunction *func, bool thereIsReturnValue); /** * Writes the Python function wrapper overload decisor that selects which C++ @@ -163,9 +163,9 @@ private: * \param s text stream to write * \param overloadData the overload data describing all the possible overloads for the function/method */ - void writeOverloadedFunctionDecisor(QTextStream& s, const OverloadData& overloadData); + void writeOverloadedFunctionDecisor(QTextStream &s, const OverloadData &overloadData); /// Recursive auxiliar method to the other writeOverloadedFunctionDecisor. - void writeOverloadedFunctionDecisorEngine(QTextStream& s, const OverloadData* parentOverloadData); + void writeOverloadedFunctionDecisorEngine(QTextStream &s, const OverloadData *parentOverloadData); /// Writes calls to all the possible method/function overloads. void writeFunctionCalls(QTextStream &s, @@ -179,55 +179,55 @@ private: GeneratorContext &context); /// Returns the name of a C++ to Python conversion function. - static QString cppToPythonFunctionName(const QString& sourceTypeName, QString targetTypeName = QString()); + static QString cppToPythonFunctionName(const QString &sourceTypeName, QString targetTypeName = QString()); /// Returns the name of a Python to C++ conversion function. - static QString pythonToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName); - static QString pythonToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType); - static QString pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, const TypeEntry* targetType); + static QString pythonToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName); + static QString pythonToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType); + static QString pythonToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, const TypeEntry *targetType); /// Returns the name of a Python to C++ convertible check function. - static QString convertibleToCppFunctionName(const QString& sourceTypeName, const QString& targetTypeName); - static QString convertibleToCppFunctionName(const AbstractMetaType* sourceType, const AbstractMetaType* targetType); - static QString convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion* toNative, const TypeEntry* targetType); + static QString convertibleToCppFunctionName(const QString &sourceTypeName, const QString &targetTypeName); + static QString convertibleToCppFunctionName(const AbstractMetaType *sourceType, const AbstractMetaType *targetType); + static QString convertibleToCppFunctionName(const CustomConversion::TargetToNativeConversion *toNative, const TypeEntry *targetType); /// Writes a C++ to Python conversion function. - void writeCppToPythonFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, QString targetTypeName = QString()); - void writeCppToPythonFunction(QTextStream& s, const CustomConversion* customConversion); - void writeCppToPythonFunction(QTextStream& s, const AbstractMetaType* containerType); + void writeCppToPythonFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, QString targetTypeName = QString()); + void writeCppToPythonFunction(QTextStream &s, const CustomConversion *customConversion); + void writeCppToPythonFunction(QTextStream &s, const AbstractMetaType *containerType); /// Writes a Python to C++ conversion function. - void writePythonToCppFunction(QTextStream& s, const QString& code, const QString& sourceTypeName, const QString& targetTypeName); + void writePythonToCppFunction(QTextStream &s, const QString &code, const QString &sourceTypeName, const QString &targetTypeName); /// Writes a Python to C++ convertible check function. - void writeIsPythonConvertibleToCppFunction(QTextStream& s, - const QString& sourceTypeName, - const QString& targetTypeName, - const QString& condition, + void writeIsPythonConvertibleToCppFunction(QTextStream &s, + const QString &sourceTypeName, + const QString &targetTypeName, + const QString &condition, QString pythonToCppFuncName = QString(), bool acceptNoneAsCppNull = false); /// Writes a pair of Python to C++ conversion and check functions. - void writePythonToCppConversionFunctions(QTextStream& s, - const AbstractMetaType* sourceType, - const AbstractMetaType* targetType, + void writePythonToCppConversionFunctions(QTextStream &s, + const AbstractMetaType *sourceType, + const AbstractMetaType *targetType, QString typeCheck = QString(), QString conversion = QString(), QString preConversion = QString()); /// Writes a pair of Python to C++ conversion and check functions for implicit conversions. - void writePythonToCppConversionFunctions(QTextStream& s, - const CustomConversion::TargetToNativeConversion* toNative, - const TypeEntry* targetType); + void writePythonToCppConversionFunctions(QTextStream &s, + const CustomConversion::TargetToNativeConversion *toNative, + const TypeEntry *targetType); /// Writes a pair of Python to C++ conversion and check functions for instantiated container types. - void writePythonToCppConversionFunctions(QTextStream& s, const AbstractMetaType* containerType); + void writePythonToCppConversionFunctions(QTextStream &s, const AbstractMetaType *containerType); - void writeAddPythonToCppConversion(QTextStream& s, const QString& converterVar, const QString& pythonToCppFunc, const QString& isConvertibleFunc); + void writeAddPythonToCppConversion(QTextStream &s, const QString &converterVar, const QString &pythonToCppFunc, const QString &isConvertibleFunc); - void writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs); + void writeNamedArgumentResolution(QTextStream &s, const AbstractMetaFunction *func, bool usePyArgs); /// Returns a string containing the name of an argument for the given function and argument index. - QString argumentNameFromIndex(const AbstractMetaFunction* func, int argIndex, const AbstractMetaClass** wrappedClass); + QString argumentNameFromIndex(const AbstractMetaFunction *func, int argIndex, const AbstractMetaClass **wrappedClass); void writeMethodCall(QTextStream &s, const AbstractMetaFunction *func, GeneratorContext &context, int maxArgs = 0); @@ -241,25 +241,25 @@ private: void writeClassDefinition(QTextStream &s, const AbstractMetaClass *metaClass, GeneratorContext &classContext); - void writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads); - void writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads); + void writeMethodDefinitionEntry(QTextStream &s, const AbstractMetaFunctionList &overloads); + void writeMethodDefinition(QTextStream &s, const AbstractMetaFunctionList &overloads); void writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads); /// Writes the implementation of all methods part of python sequence protocol void writeSequenceMethods(QTextStream &s, const AbstractMetaClass *metaClass, GeneratorContext &context); - void writeTypeAsSequenceDefinition(QTextStream& s, const AbstractMetaClass* metaClass); + void writeTypeAsSequenceDefinition(QTextStream &s, const AbstractMetaClass *metaClass); /// Writes the PyMappingMethods structure for types that supports the python mapping protocol. - void writeTypeAsMappingDefinition(QTextStream& s, const AbstractMetaClass* metaClass); + void writeTypeAsMappingDefinition(QTextStream &s, const AbstractMetaClass *metaClass); void writeMappingMethods(QTextStream &s, const AbstractMetaClass *metaClass, GeneratorContext &context); - void writeTypeAsNumberDefinition(QTextStream& s, const AbstractMetaClass* metaClass); + void writeTypeAsNumberDefinition(QTextStream &s, const AbstractMetaClass *metaClass); - void writeTpTraverseFunction(QTextStream& s, const AbstractMetaClass* metaClass); - void writeTpClearFunction(QTextStream& s, const AbstractMetaClass* metaClass); + void writeTpTraverseFunction(QTextStream &s, const AbstractMetaClass *metaClass); + void writeTpClearFunction(QTextStream &s, const AbstractMetaClass *metaClass); void writeCopyFunction(QTextStream &s, GeneratorContext &context); @@ -272,35 +272,35 @@ private: void writeRichCompareFunction(QTextStream &s, GeneratorContext &context); - void writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList& enums); - void writeEnumInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum); + void writeEnumsInitialization(QTextStream &s, AbstractMetaEnumList &enums); + void writeEnumInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum); - void writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass); + void writeSignalInitialization(QTextStream &s, const AbstractMetaClass *metaClass); - void writeFlagsMethods(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeFlagsToLong(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum, + void writeFlagsMethods(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeFlagsToLong(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeFlagsNonZero(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeFlagsNumberMethodsDefinition(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeFlagsBinaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum, const QString &pyOpName, const QString &cppOpName); - void writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum, + void writeFlagsUnaryOperator(QTextStream &s, const AbstractMetaEnum *cppEnum, const QString &pyOpName, const QString &cppOpName, bool boolResult = false); /// Writes the function that registers the multiple inheritance information for the classes that need it. - void writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass); + void writeMultipleInheritanceInitializerFunction(QTextStream &s, const AbstractMetaClass *metaClass); /// Writes the implementation of special cast functions, used when we need to cast a class with multiple inheritance. - void writeSpecialCastFunction(QTextStream& s, const AbstractMetaClass* metaClass); + void writeSpecialCastFunction(QTextStream &s, const AbstractMetaClass *metaClass); - void writePrimitiveConverterInitialization(QTextStream& s, const CustomConversion* customConversion); - void writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType); - void writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum); - void writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type); - void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QVector& conversions); + void writePrimitiveConverterInitialization(QTextStream &s, const CustomConversion *customConversion); + void writeEnumConverterInitialization(QTextStream &s, const TypeEntry *enumType); + void writeEnumConverterInitialization(QTextStream &s, const AbstractMetaEnum *metaEnum); + void writeContainerConverterInitialization(QTextStream &s, const AbstractMetaType *type); + void writeExtendedConverterInitialization(QTextStream &s, const TypeEntry *externalType, const QVector& conversions); - void writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool userHeuristicForReturn); - bool writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool userHeuristicPolicy); - void writeReturnValueHeuristics(QTextStream& s, const AbstractMetaFunction* func, const QString& self = QLatin1String("self")); + void writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, bool userHeuristicForReturn); + bool writeParentChildManagement(QTextStream &s, const AbstractMetaFunction *func, int argIndex, bool userHeuristicPolicy); + void writeReturnValueHeuristics(QTextStream &s, const AbstractMetaFunction *func, const QString &self = QLatin1String("self")); void writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorContext &context) const; /** @@ -309,34 +309,34 @@ private: * \return name of the multiple inheritance information initializer function or * an empty string if there is no multiple inheritance in its ancestry. */ - QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass* metaClass); + QString multipleInheritanceInitializerFunctionName(const AbstractMetaClass *metaClass); /// Returns a list of all classes to which the given class could be cast. - QStringList getAncestorMultipleInheritance(const AbstractMetaClass* metaClass); + QStringList getAncestorMultipleInheritance(const AbstractMetaClass *metaClass); /// Returns true if the given class supports the python number protocol - bool supportsNumberProtocol(const AbstractMetaClass* metaClass); + bool supportsNumberProtocol(const AbstractMetaClass *metaClass); /// Returns true if the given class supports the python sequence protocol - bool supportsSequenceProtocol(const AbstractMetaClass* metaClass); + bool supportsSequenceProtocol(const AbstractMetaClass *metaClass); /// Returns true if the given class supports the python mapping protocol - bool supportsMappingProtocol(const AbstractMetaClass* metaClass); + bool supportsMappingProtocol(const AbstractMetaClass *metaClass); /// Returns true if generator should produce getters and setters for the given class. - bool shouldGenerateGetSetList(const AbstractMetaClass* metaClass); + bool shouldGenerateGetSetList(const AbstractMetaClass *metaClass); void writeHashFunction(QTextStream &s, GeneratorContext &context); /// Write default implementations for sequence protocol void writeStdListWrapperMethods(QTextStream &s, GeneratorContext &context); /// Helper function for writeStdListWrapperMethods. - void writeIndexError(QTextStream& s, const QString& errorMsg); + void writeIndexError(QTextStream &s, const QString &errorMsg); QString writeReprFunction(QTextStream &s, GeneratorContext &context); - const AbstractMetaFunction *boolCast(const AbstractMetaClass* metaClass) const; - bool hasBoolCast(const AbstractMetaClass* metaClass) const + const AbstractMetaFunction *boolCast(const AbstractMetaClass *metaClass) const; + bool hasBoolCast(const AbstractMetaClass *metaClass) const { return boolCast(metaClass) != nullptr; } // Number protocol structure members names. diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.cpp b/sources/shiboken2/generator/shiboken2/headergenerator.cpp index a55539d7c..82b2d96d6 100644 --- a/sources/shiboken2/generator/shiboken2/headergenerator.cpp +++ b/sources/shiboken2/generator/shiboken2/headergenerator.cpp @@ -58,7 +58,7 @@ QString HeaderGenerator::fileNameForContext(GeneratorContext &context) const return fileNameBase + fileNameSuffix(); } -void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* metaClass) const +void HeaderGenerator::writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const { s << INDENT << wrapperName(metaClass) << "(const " << metaClass->qualifiedCppName() << "& self)"; s << " : " << metaClass->qualifiedCppName() << "(self)" << endl; @@ -66,7 +66,7 @@ void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* met s << INDENT << "}" << endl << endl; } -void HeaderGenerator::writeProtectedFieldAccessors(QTextStream& s, const AbstractMetaField* field) const +void HeaderGenerator::writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) const { AbstractMetaType *metaType = field->type(); QString fieldType = metaType->cppSignature(); @@ -81,10 +81,10 @@ void HeaderGenerator::writeProtectedFieldAccessors(QTextStream& s, const Abstrac // Get function s << INDENT << "inline " << fieldType - << (useReference ? '*' : ' ') + << (useReference ? " *" : " ") << ' ' << protectedFieldGetterName(field) << "()" << " { return " - << (useReference ? '&' : ' ') << "this->" << fieldName << "; }" << endl; + << (useReference ? " &" : " ") << "this->" << fieldName << "; }" << endl; // Set function s << INDENT << "inline void " << protectedFieldSetterName(field) << '(' << fieldType << " value)" @@ -169,8 +169,8 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte if ((!avoidProtectedHack() || !metaClass->hasPrivateDestructor()) && usePySideExtensions() && metaClass->isQObject()) { s << "public:\n"; - s << INDENT << "int qt_metacall(QMetaObject::Call call, int id, void** args) override;" << endl; - s << INDENT << "void* qt_metacast(const char* _clname) override;" << endl; + s << INDENT << "int qt_metacall(QMetaObject::Call call, int id, void **args) override;" << endl; + s << INDENT << "void *qt_metacast(const char *_clname) override;" << endl; } if (!m_inheritedOverloads.isEmpty()) { @@ -205,7 +205,7 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte s << "#endif // SBK_" << outerHeaderGuard << "_H" << endl << endl; } -void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction* func) +void HeaderGenerator::writeFunction(QTextStream &s, const AbstractMetaFunction *func) { // do not write copy ctors here. @@ -228,9 +228,9 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction* const AbstractMetaArgumentList &arguments = func->arguments(); for (const AbstractMetaArgument *arg : arguments) { QString argName = arg->name(); - const TypeEntry* enumTypeEntry = 0; + const TypeEntry *enumTypeEntry = nullptr; if (arg->type()->isFlags()) - enumTypeEntry = static_cast(arg->type()->typeEntry())->originator(); + enumTypeEntry = static_cast(arg->type()->typeEntry())->originator(); else if (arg->type()->isEnum()) enumTypeEntry = arg->type()->typeEntry(); if (enumTypeEntry) @@ -284,7 +284,7 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction* } } -static void _writeTypeIndexValue(QTextStream& s, const QString& variableName, +static void _writeTypeIndexValue(QTextStream &s, const QString &variableName, int typeIndex) { s << " "; @@ -294,15 +294,15 @@ static void _writeTypeIndexValue(QTextStream& s, const QString& variableName, s << " = " << typeIndex; } -static inline void _writeTypeIndexValueLine(QTextStream& s, - const QString& variableName, +static inline void _writeTypeIndexValueLine(QTextStream &s, + const QString &variableName, int typeIndex) { _writeTypeIndexValue(s, variableName, typeIndex); s << ",\n"; } -void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* typeEntry) +void HeaderGenerator::writeTypeIndexValueLine(QTextStream &s, const TypeEntry *typeEntry) { if (!typeEntry || !typeEntry->generateCode()) return; @@ -310,7 +310,7 @@ void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* t const int typeIndex = typeEntry->sbkIndex(); _writeTypeIndexValueLine(s, getTypeIndexVariableName(typeEntry), typeIndex); if (typeEntry->isComplex()) { - const ComplexTypeEntry* cType = static_cast(typeEntry); + const ComplexTypeEntry *cType = static_cast(typeEntry); if (cType->baseContainerType()) { const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), cType); if (metaClass->templateBaseClass()) @@ -318,13 +318,13 @@ void HeaderGenerator::writeTypeIndexValueLine(QTextStream& s, const TypeEntry* t } } if (typeEntry->isEnum()) { - const EnumTypeEntry* ete = static_cast(typeEntry); + auto ete = static_cast(typeEntry); if (ete->flags()) writeTypeIndexValueLine(s, ete->flags()); } } -void HeaderGenerator::writeTypeIndexValueLines(QTextStream& s, const AbstractMetaClass* metaClass) +void HeaderGenerator::writeTypeIndexValueLines(QTextStream &s, const AbstractMetaClass *metaClass) { if (!metaClass->typeEntry()->generateCode()) return; @@ -383,7 +383,7 @@ bool HeaderGenerator::finishGeneration() AbstractMetaEnumList globalEnums = this->globalEnums(); AbstractMetaClassList classList = classes(); - std::sort(classList.begin(), classList.end(), [](AbstractMetaClass *a, AbstractMetaClass* b) { + std::sort(classList.begin(), classList.end(), [](AbstractMetaClass *a, AbstractMetaClass *b) { return a->typeEntry()->sbkIndex() < b->typeEntry()->sbkIndex(); }); @@ -413,11 +413,11 @@ bool HeaderGenerator::finishGeneration() macrosStream << "\n};\n"; macrosStream << "// This variable stores all Python types exported by this module." << endl; - macrosStream << "extern PyTypeObject** " << cppApiVariableName() << ';' << endl << endl; + macrosStream << "extern PyTypeObject **" << cppApiVariableName() << ';' << endl << endl; macrosStream << "// This variable stores the Python module object exported by this module." << endl; - macrosStream << "extern PyObject* " << pythonModuleObjectName() << ';' << endl << endl; + macrosStream << "extern PyObject *" << pythonModuleObjectName() << ';' << endl << endl; macrosStream << "// This variable stores all type converters exported by this module." << endl; - macrosStream << "extern SbkConverter** " << convertersVariableName() << ';' << endl << endl; + macrosStream << "extern SbkConverter **" << convertersVariableName() << ';' << endl << endl; // TODO-CONVERTER ------------------------------------------------------------------------------ // Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex(). @@ -467,14 +467,14 @@ bool HeaderGenerator::finishGeneration() continue; //Includes - const TypeEntry* classType = metaClass->typeEntry(); + const TypeEntry *classType = metaClass->typeEntry(); includes << classType->include(); const AbstractMetaEnumList &enums = metaClass->enums(); for (const AbstractMetaEnum *cppEnum : enums) { if (cppEnum->isAnonymous() || cppEnum->isPrivate()) continue; - EnumTypeEntry* enumType = cppEnum->typeEntry(); + EnumTypeEntry *enumType = cppEnum->typeEntry(); includes << enumType->include(); writeProtectedEnumSurrogate(protEnumsSurrogates, cppEnum); writeSbkTypeFunction(typeFunctions, cppEnum); @@ -497,7 +497,7 @@ bool HeaderGenerator::finishGeneration() QString includeShield(QLatin1String("SBK_") + moduleName().toUpper() + QLatin1String("_PYTHON_H")); FileOut file(moduleHeaderFileName); - QTextStream& s = file.stream; + QTextStream &s = file.stream; // write license comment s << licenseComment() << endl << endl; @@ -558,13 +558,13 @@ bool HeaderGenerator::finishGeneration() return file.done() != FileOut::Failure; } -void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream& s, const AbstractMetaEnum* cppEnum) +void HeaderGenerator::writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum) { if (avoidProtectedHack() && cppEnum->isProtected()) s << "enum " << protectedEnumSurrogateName(cppEnum) << " {};" << endl; } -void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnum* cppEnum) +void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum) { QString enumName; if (avoidProtectedHack() && cppEnum->isProtected()) { @@ -575,29 +575,29 @@ void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnu enumName = cppEnum->enclosingClass()->qualifiedCppName() + QLatin1String("::") + enumName; } - s << "template<> inline PyTypeObject* SbkType< ::" << enumName << " >() "; + s << "template<> inline PyTypeObject *SbkType< ::" << enumName << " >() "; s << "{ return " << cpythonTypeNameExt(cppEnum->typeEntry()) << "; }\n"; - FlagsTypeEntry* flag = cppEnum->typeEntry()->flags(); + FlagsTypeEntry *flag = cppEnum->typeEntry()->flags(); if (flag) { - s << "template<> inline PyTypeObject* SbkType< ::" << flag->name() << " >() " + s << "template<> inline PyTypeObject *SbkType< ::" << flag->name() << " >() " << "{ return " << cpythonTypeNameExt(flag) << "; }\n"; } } -void HeaderGenerator::writeSbkTypeFunction(QTextStream& s, const AbstractMetaClass* cppClass) +void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaClass *cppClass) { - s << "template<> inline PyTypeObject* SbkType< ::" << cppClass->qualifiedCppName() << " >() " - << "{ return reinterpret_cast(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n"; + s << "template<> inline PyTypeObject *SbkType< ::" << cppClass->qualifiedCppName() << " >() " + << "{ return reinterpret_cast(" << cpythonTypeNameExt(cppClass->typeEntry()) << "); }\n"; } void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaType *metaType) { - s << "template<> inline PyTypeObject* SbkType< ::" << metaType->cppSignature() << " >() " - << "{ return reinterpret_cast(" << cpythonTypeNameExt(metaType) << "); }\n"; + s << "template<> inline PyTypeObject *SbkType< ::" << metaType->cppSignature() << " >() " + << "{ return reinterpret_cast(" << cpythonTypeNameExt(metaType) << "); }\n"; } -void HeaderGenerator::writeInheritedOverloads(QTextStream& s) +void HeaderGenerator::writeInheritedOverloads(QTextStream &s) { for (const AbstractMetaFunction *func : qAsConst(m_inheritedOverloads)) { s << INDENT << "inline "; @@ -608,9 +608,9 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream& s) const AbstractMetaArgumentList &arguments = func->arguments(); for (const AbstractMetaArgument *arg : arguments) { QString argName = arg->name(); - const TypeEntry* enumTypeEntry = 0; + const TypeEntry *enumTypeEntry = nullptr; if (arg->type()->isFlags()) - enumTypeEntry = static_cast(arg->type()->typeEntry())->originator(); + enumTypeEntry = static_cast(arg->type()->typeEntry())->originator(); else if (arg->type()->isEnum()) enumTypeEntry = arg->type()->typeEntry(); if (enumTypeEntry) diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.h b/sources/shiboken2/generator/shiboken2/headergenerator.h index f59e0fd9a..5f59dd13a 100644 --- a/sources/shiboken2/generator/shiboken2/headergenerator.h +++ b/sources/shiboken2/generator/shiboken2/headergenerator.h @@ -48,22 +48,22 @@ public: protected: QString fileNameSuffix() const override; QString fileNameForContext(GeneratorContext &context) const override; - void generateClass(QTextStream& s, GeneratorContext &classContext) override; + void generateClass(QTextStream &s, GeneratorContext &classContext) override; bool finishGeneration() override; private: - void writeCopyCtor(QTextStream &s, const AbstractMetaClass* metaClass) const; - void writeProtectedFieldAccessors(QTextStream& s, const AbstractMetaField* field) const; - void writeFunction(QTextStream& s, const AbstractMetaFunction* func); - void writeSbkTypeFunction(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeSbkTypeFunction(QTextStream& s, const AbstractMetaClass* cppClass); + void writeCopyCtor(QTextStream &s, const AbstractMetaClass *metaClass) const; + void writeProtectedFieldAccessors(QTextStream &s, const AbstractMetaField *field) const; + void writeFunction(QTextStream &s, const AbstractMetaFunction *func); + void writeSbkTypeFunction(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeSbkTypeFunction(QTextStream &s, const AbstractMetaClass *cppClass); void writeSbkTypeFunction(QTextStream &s, const AbstractMetaType *metaType); - void writeTypeIndexValueLine(QTextStream& s, const TypeEntry* typeEntry); - void writeTypeIndexValueLines(QTextStream& s, const AbstractMetaClass* metaClass); - void writeProtectedEnumSurrogate(QTextStream& s, const AbstractMetaEnum* cppEnum); - void writeInheritedOverloads(QTextStream& s); + void writeTypeIndexValueLine(QTextStream &s, const TypeEntry *typeEntry); + void writeTypeIndexValueLines(QTextStream &s, const AbstractMetaClass *metaClass); + void writeProtectedEnumSurrogate(QTextStream &s, const AbstractMetaEnum *cppEnum); + void writeInheritedOverloads(QTextStream &s); - QSet m_inheritedOverloads; + QSet m_inheritedOverloads; }; #endif // HEADERGENERATOR_H diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.cpp b/sources/shiboken2/generator/shiboken2/overloaddata.cpp index becd66879..89c73576e 100644 --- a/sources/shiboken2/generator/shiboken2/overloaddata.cpp +++ b/sources/shiboken2/generator/shiboken2/overloaddata.cpp @@ -40,7 +40,7 @@ static const TypeEntry *getReferencedTypeEntry(const TypeEntry *typeEntry) { if (typeEntry->isPrimitive()) { - const PrimitiveTypeEntry* pte = dynamic_cast(typeEntry); + auto pte = dynamic_cast(typeEntry); while (pte->referencedTypeEntry()) pte = pte->referencedTypeEntry(); typeEntry = pte; @@ -48,9 +48,9 @@ static const TypeEntry *getReferencedTypeEntry(const TypeEntry *typeEntry) return typeEntry; } -static QString getTypeName(const AbstractMetaType* type) +static QString getTypeName(const AbstractMetaType *type) { - const TypeEntry* typeEntry = getReferencedTypeEntry(type->typeEntry()); + const TypeEntry *typeEntry = getReferencedTypeEntry(type->typeEntry()); QString typeName = typeEntry->name(); if (typeEntry->isContainer()) { QStringList types; @@ -64,12 +64,12 @@ static QString getTypeName(const AbstractMetaType* type) return typeName; } -static QString getTypeName(const OverloadData* ov) +static QString getTypeName(const OverloadData *ov) { return ov->hasArgumentTypeReplace() ? ov->argumentTypeReplaced() : getTypeName(ov->argType()); } -static bool typesAreEqual(const AbstractMetaType* typeA, const AbstractMetaType* typeB) +static bool typesAreEqual(const AbstractMetaType *typeA, const AbstractMetaType *typeB) { if (typeA->typeEntry() == typeB->typeEntry()) { if (typeA->isContainer() || typeA->isSmartPointer()) { @@ -100,7 +100,7 @@ struct OverloadSortData * a OverloadData. This is done to express type dependencies that could * or could not appear in overloaded signatures not processed yet. */ - void mapType(const QString& typeName) + void mapType(const QString &typeName) { if (map.contains(typeName)) return; @@ -110,7 +110,7 @@ struct OverloadSortData counter++; } - void mapType(OverloadData* overloadData) + void mapType(OverloadData *overloadData) { QString typeName = getTypeName(overloadData); map[typeName] = counter; @@ -122,7 +122,7 @@ struct OverloadSortData int counter = 0; QHash map; // typeName -> id - QHash reverseMap; // id -> OverloadData; + QHash reverseMap; // id -> OverloadData; }; /** @@ -130,10 +130,10 @@ struct OverloadSortData * an instantiation taken either from an implicit conversion expressed by the function argument, * or from the string argument implicitConvTypeName. */ -static QString getImplicitConversionTypeName(const AbstractMetaType* containerType, - const AbstractMetaType* instantiation, - const AbstractMetaFunction* function, - const QString& implicitConvTypeName = QString()) +static QString getImplicitConversionTypeName(const AbstractMetaType *containerType, + const AbstractMetaType *instantiation, + const AbstractMetaFunction *function, + const QString &implicitConvTypeName = QString()) { QString impConv; if (!implicitConvTypeName.isEmpty()) @@ -267,7 +267,7 @@ void OverloadData::sortNextOverloads() // Create the graph of type dependencies based on implicit conversions. Graph graph(sortData.reverseMap.count()); // All C++ primitive types, add any forgotten type AT THE END OF THIS LIST! - const char* primitiveTypes[] = {"int", + const char *primitiveTypes[] = {"int", "unsigned int", "long", "unsigned long", @@ -280,7 +280,7 @@ void OverloadData::sortNextOverloads() "double", "const char*" }; - const int numPrimitives = sizeof(primitiveTypes)/sizeof(const char*); + const int numPrimitives = sizeof(primitiveTypes)/sizeof(const char *); bool hasPrimitive[numPrimitives]; for (int i = 0; i < numPrimitives; ++i) hasPrimitive[i] = sortData.map.contains(QLatin1String(primitiveTypes[i])); @@ -293,7 +293,7 @@ void OverloadData::sortNextOverloads() MetaFunctionList involvedConversions; for (OverloadData *ov : qAsConst(m_nextOverloadData)) { - const AbstractMetaType* targetType = ov->argType(); + const AbstractMetaType *targetType = ov->argType(); const QString targetTypeEntryName(getTypeName(ov)); int targetTypeId = sortData.map[targetTypeEntryName]; @@ -404,7 +404,7 @@ void OverloadData::sortNextOverloads() graph.addEdge(sortData.map[QLatin1String("QString")], sortData.map[QLatin1String("QByteArray")]); for (OverloadData *ov : qAsConst(m_nextOverloadData)) { - const AbstractMetaType* targetType = ov->argType(); + const AbstractMetaType *targetType = ov->argType(); if (!targetType->isEnum()) continue; @@ -462,11 +462,11 @@ void OverloadData::sortNextOverloads() * * Given these two overloads, there will be the following graph: * - * addStuff - double - PyObject* + * addStuff - double - PyObject * * \- int * */ -OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator) +OverloadData::OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator) : m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(0), m_headOverloadData(this), m_previousOverloadData(0), m_generator(generator) { @@ -477,7 +477,7 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib m_minArgs = argSize; else if (m_maxArgs < argSize) m_maxArgs = argSize; - OverloadData* currentOverloadData = this; + OverloadData *currentOverloadData = this; const AbstractMetaArgumentList &arguments = func->arguments(); for (const AbstractMetaArgument *arg : arguments) { if (func->argumentRemoved(arg->argumentIndex() + 1)) @@ -495,8 +495,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib m_headOverloadData->m_minArgs = maxArgs(); } -OverloadData::OverloadData(OverloadData* headOverloadData, const AbstractMetaFunction* func, - const AbstractMetaType* argType, int argPos) +OverloadData::OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func, + const AbstractMetaType *argType, int argPos) : m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType), m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr), m_generator(nullptr) @@ -505,7 +505,7 @@ OverloadData::OverloadData(OverloadData* headOverloadData, const AbstractMetaFun this->addOverload(func); } -void OverloadData::addOverload(const AbstractMetaFunction* func) +void OverloadData::addOverload(const AbstractMetaFunction *func) { int origNumArgs = func->arguments().size(); int removed = numberOfRemovedArguments(func); @@ -530,11 +530,11 @@ void OverloadData::addOverload(const AbstractMetaFunction* func) m_overloads.append(func); } -OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func, - const AbstractMetaArgument* arg) +OverloadData *OverloadData::addOverloadData(const AbstractMetaFunction *func, + const AbstractMetaArgument *arg) { - const AbstractMetaType* argType = arg->type(); - OverloadData* overloadData = 0; + const AbstractMetaType *argType = arg->type(); + OverloadData *overloadData = nullptr; if (!func->isOperatorOverload()) { for (OverloadData *tmp : qAsConst(m_nextOverloadData)) { // TODO: 'const char *', 'char *' and 'char' will have the same TypeEntry? @@ -604,7 +604,7 @@ bool OverloadData::hasAllowThread() const return false; } -bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads) +bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList &overloads) { for (const AbstractMetaFunction *func : qAsConst(overloads)) { if (func->isStatic()) @@ -622,7 +622,7 @@ bool OverloadData::hasStaticFunction() const return false; } -bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads) +bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList &overloads) { for (const AbstractMetaFunction *func : qAsConst(overloads)) { if (!func->isStatic()) @@ -640,7 +640,7 @@ bool OverloadData::hasInstanceFunction() const return false; } -bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionList& overloads) +bool OverloadData::hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads) { return OverloadData::hasStaticFunction(overloads) && OverloadData::hasInstanceFunction(overloads); } @@ -650,12 +650,12 @@ bool OverloadData::hasStaticAndInstanceFunctions() const return OverloadData::hasStaticFunction() && OverloadData::hasInstanceFunction(); } -const AbstractMetaFunction* OverloadData::referenceFunction() const +const AbstractMetaFunction *OverloadData::referenceFunction() const { return m_overloads.constFirst(); } -const AbstractMetaArgument* OverloadData::argument(const AbstractMetaFunction* func) const +const AbstractMetaArgument *OverloadData::argument(const AbstractMetaFunction *func) const { if (isHeadOverloadData() || !m_overloads.contains(func)) return 0; @@ -672,7 +672,7 @@ const AbstractMetaArgument* OverloadData::argument(const AbstractMetaFunction* f return func->arguments().at(m_argPos + removed); } -OverloadDataList OverloadData::overloadDataOnPosition(OverloadData* overloadData, int argPos) const +OverloadDataList OverloadData::overloadDataOnPosition(OverloadData *overloadData, int argPos) const { OverloadDataList overloadDataList; if (overloadData->argPos() == argPos) { @@ -701,27 +701,27 @@ bool OverloadData::nextArgumentHasDefaultValue() const return false; } -static OverloadData* _findNextArgWithDefault(OverloadData* overloadData) +static OverloadData *_findNextArgWithDefault(OverloadData *overloadData) { if (overloadData->getFunctionWithDefaultValue()) return overloadData; - OverloadData* result = 0; + OverloadData *result = nullptr; const OverloadDataList &data = overloadData->nextOverloadData(); for (OverloadData *odata : data) { - OverloadData* tmp = _findNextArgWithDefault(odata); + OverloadData *tmp = _findNextArgWithDefault(odata); if (!result || (tmp && result->argPos() > tmp->argPos())) result = tmp; } return result; } -OverloadData* OverloadData::findNextArgWithDefault() +OverloadData *OverloadData::findNextArgWithDefault() { return _findNextArgWithDefault(this); } -bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const +bool OverloadData::isFinalOccurrence(const AbstractMetaFunction *func) const { for (const OverloadData *pd : m_nextOverloadData) { if (pd->overloads().contains(func)) @@ -746,7 +746,7 @@ OverloadData::MetaFunctionList OverloadData::overloadsWithoutRepetition() const return overloads; } -const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const +const AbstractMetaFunction *OverloadData::getFunctionWithDefaultValue() const { for (const AbstractMetaFunction *func : m_overloads) { int removedArgs = 0; @@ -787,7 +787,7 @@ QVector OverloadData::invalidArgumentLengths() const return invalidArgLengths; } -int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos) +int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos) { int removed = 0; if (finalArgPos < 0) { @@ -804,7 +804,7 @@ int OverloadData::numberOfRemovedArguments(const AbstractMetaFunction* func, int return removed; } -QPair OverloadData::getMinMaxArguments(const AbstractMetaFunctionList& overloads) +QPair OverloadData::getMinMaxArguments(const AbstractMetaFunctionList &overloads) { int minArgs = 10000; int maxArgs = 0; @@ -827,7 +827,7 @@ QPair OverloadData::getMinMaxArguments(const AbstractMetaFunctionList& return {minArgs, maxArgs}; } -bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads) +bool OverloadData::isSingleArgument(const AbstractMetaFunctionList &overloads) { bool singleArgument = true; for (const AbstractMetaFunction *func : overloads) { @@ -863,7 +863,7 @@ QString OverloadData::dumpGraph() const QString result; QTextStream s(&result); if (m_argPos == -1) { - const AbstractMetaFunction* rfunc = referenceFunction(); + const AbstractMetaFunction *rfunc = referenceFunction(); s << "digraph OverloadedFunction {" << endl; s << INDENT << "graph [fontsize=12 fontname=freemono labelloc=t splines=true overlap=false rankdir=LR];" << endl; @@ -964,7 +964,7 @@ QString OverloadData::dumpGraph() const // Show default values (original and modified) for various functions for (const AbstractMetaFunction *func : m_overloads) { - const AbstractMetaArgument* arg = argument(func); + const AbstractMetaArgument *arg = argument(func); if (!arg) continue; QString argDefault = ShibokenGenerator::getDefaultValue(func, arg); @@ -989,7 +989,7 @@ QString OverloadData::dumpGraph() const return result; } -int OverloadData::functionNumber(const AbstractMetaFunction* func) const +int OverloadData::functionNumber(const AbstractMetaFunction *func) const { return m_headOverloadData->m_overloads.indexOf(func); } @@ -1010,7 +1010,7 @@ QString OverloadData::argumentTypeReplaced() const return m_argTypeReplaced; } -bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList& overloads) +bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads) { if (OverloadData::getMinMaxArguments(overloads).second == 0) return false; @@ -1032,7 +1032,7 @@ bool OverloadData::hasArgumentWithDefaultValue() const return false; } -bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func) +bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction *func) { const AbstractMetaArgumentList &arguments = func->arguments(); for (const AbstractMetaArgument *arg : arguments) { @@ -1044,7 +1044,7 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func) return false; } -AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction* func) +AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction *func) { AbstractMetaArgumentList args; const AbstractMetaArgumentList &arguments = func->arguments(); diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.h b/sources/shiboken2/generator/shiboken2/overloaddata.h index 4759ca9c3..c9304d461 100644 --- a/sources/shiboken2/generator/shiboken2/overloaddata.h +++ b/sources/shiboken2/generator/shiboken2/overloaddata.h @@ -45,14 +45,14 @@ class OverloadData public: typedef QVector MetaFunctionList; - OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator); + OverloadData(const AbstractMetaFunctionList &overloads, const ShibokenGenerator *generator); ~OverloadData(); int minArgs() const { return m_headOverloadData->m_minArgs; } int maxArgs() const { return m_headOverloadData->m_maxArgs; } int argPos() const { return m_argPos; } - const AbstractMetaType* argType() const { return m_argType; } + const AbstractMetaType *argType() const { return m_argType; } /// Returns a string list containing all the possible return types (including void) for the current OverloadData. QStringList returnTypes() const; @@ -70,49 +70,49 @@ public: bool hasStaticFunction() const; /// Returns true if any of the overloads passed as argument is static. - static bool hasStaticFunction(const AbstractMetaFunctionList& overloads); + static bool hasStaticFunction(const AbstractMetaFunctionList &overloads); /// Returns true if any of the overloads for the current OverloadData is not static. bool hasInstanceFunction() const; /// Returns true if any of the overloads passed as argument is not static. - static bool hasInstanceFunction(const AbstractMetaFunctionList& overloads); + static bool hasInstanceFunction(const AbstractMetaFunctionList &overloads); /// Returns true if among the overloads for the current OverloadData there are static and non-static methods altogether. bool hasStaticAndInstanceFunctions() const; /// Returns true if among the overloads passed as argument there are static and non-static methods altogether. - static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionList& overloads); + static bool hasStaticAndInstanceFunctions(const AbstractMetaFunctionList &overloads); - const AbstractMetaFunction* referenceFunction() const; - const AbstractMetaArgument* argument(const AbstractMetaFunction* func) const; + const AbstractMetaFunction *referenceFunction() const; + const AbstractMetaArgument *argument(const AbstractMetaFunction *func) const; OverloadDataList overloadDataOnPosition(int argPos) const; bool isHeadOverloadData() const { return this == m_headOverloadData; } /// Returns the root OverloadData object that represents all the overloads. - OverloadData* headOverloadData() const { return m_headOverloadData; } + OverloadData *headOverloadData() const { return m_headOverloadData; } /// Returns the function that has a default value at the current OverloadData argument position, otherwise returns null. - const AbstractMetaFunction* getFunctionWithDefaultValue() const; + const AbstractMetaFunction *getFunctionWithDefaultValue() const; bool nextArgumentHasDefaultValue() const; /// Returns the nearest occurrence, including this instance, of an argument with a default value. - OverloadData* findNextArgWithDefault(); - bool isFinalOccurrence(const AbstractMetaFunction* func) const; + OverloadData *findNextArgWithDefault(); + bool isFinalOccurrence(const AbstractMetaFunction *func) const; /// Returns the list of overloads removing repeated constant functions (ex.: "foo()" and "foo()const", the second is removed). MetaFunctionList overloadsWithoutRepetition() const; - const MetaFunctionList& overloads() const { return m_overloads; } + const MetaFunctionList &overloads() const { return m_overloads; } OverloadDataList nextOverloadData() const { return m_nextOverloadData; } - OverloadData* previousOverloadData() const { return m_previousOverloadData; } + OverloadData *previousOverloadData() const { return m_previousOverloadData; } QVector invalidArgumentLengths() const; - static int numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos = -1); - static QPair getMinMaxArguments(const AbstractMetaFunctionList& overloads); + static int numberOfRemovedArguments(const AbstractMetaFunction *func, int finalArgPos = -1); + static QPair getMinMaxArguments(const AbstractMetaFunctionList &overloads); /// Returns true if all overloads have no more than one argument. - static bool isSingleArgument(const AbstractMetaFunctionList& overloads); + static bool isSingleArgument(const AbstractMetaFunctionList &overloads); void dumpGraph(const QString &filename) const; QString dumpGraph() const; @@ -121,39 +121,39 @@ public: QString argumentTypeReplaced() const; bool hasArgumentWithDefaultValue() const; - static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionList& overloads); - static bool hasArgumentWithDefaultValue(const AbstractMetaFunction* func); + static bool hasArgumentWithDefaultValue(const AbstractMetaFunctionList &overloads); + static bool hasArgumentWithDefaultValue(const AbstractMetaFunction *func); /// Returns a list of function arguments which have default values and were not removed. - static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunction* func); + static AbstractMetaArgumentList getArgumentsWithDefaultValues(const AbstractMetaFunction *func); #ifndef QT_NO_DEBUG_STREAM void formatDebug(QDebug &) const; #endif private: - OverloadData(OverloadData* headOverloadData, const AbstractMetaFunction* func, - const AbstractMetaType* argType, int argPos); + OverloadData(OverloadData *headOverloadData, const AbstractMetaFunction *func, + const AbstractMetaType *argType, int argPos); - void addOverload(const AbstractMetaFunction* func); - OverloadData* addOverloadData(const AbstractMetaFunction* func, const AbstractMetaArgument* arg); + void addOverload(const AbstractMetaFunction *func); + OverloadData *addOverloadData(const AbstractMetaFunction *func, const AbstractMetaArgument *arg); void sortNextOverloads(); - int functionNumber(const AbstractMetaFunction* func) const; - OverloadDataList overloadDataOnPosition(OverloadData* overloadData, int argPos) const; + int functionNumber(const AbstractMetaFunction *func) const; + OverloadDataList overloadDataOnPosition(OverloadData *overloadData, int argPos) const; int m_minArgs; int m_maxArgs; int m_argPos; - const AbstractMetaType* m_argType; + const AbstractMetaType *m_argType; QString m_argTypeReplaced; MetaFunctionList m_overloads; - OverloadData* m_headOverloadData; + OverloadData *m_headOverloadData; OverloadDataList m_nextOverloadData; - OverloadData* m_previousOverloadData; - const ShibokenGenerator* m_generator; + OverloadData *m_previousOverloadData; + const ShibokenGenerator *m_generator; }; #ifndef QT_NO_DEBUG_STREAM diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp index 2b3b20c75..9ed175af4 100644 --- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp +++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp @@ -62,7 +62,7 @@ const char *SMART_POINTER_GETTER = "kSmartPointerGetter"; const char *CONV_RULE_OUT_VAR_SUFFIX = "_out"; const char *BEGIN_ALLOW_THREADS = - "PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS"; + "PyThreadState *_save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS"; const char *END_ALLOW_THREADS = "PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS"; //static void dumpFunction(AbstractMetaFunctionList lst); @@ -277,15 +277,15 @@ void ShibokenGenerator::initKnownPythonTypes() << QLatin1String("PyObject*") << QLatin1String("PyObject *") << QLatin1String("PyTupleObject*"); } -QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType* cType, - const AbstractMetaClass* context, +QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType *cType, + const AbstractMetaClass *context, Options options) const { if (cType->isArray()) return translateTypeForWrapperMethod(cType->arrayElementType(), context, options) + QLatin1String("[]"); if (avoidProtectedHack() && cType->isEnum()) { - const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(cType); + const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(cType); if (metaEnum && metaEnum->isProtected()) return protectedEnumSurrogateName(metaEnum); } @@ -293,7 +293,7 @@ QString ShibokenGenerator::translateTypeForWrapperMethod(const AbstractMetaType* return translateType(cType, context, options); } -bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaClass) const +bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const { if (metaClass->isNamespace() || (metaClass->attributes() & AbstractMetaAttributes::FinalCppClass)) return false; @@ -320,7 +320,7 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaCl return result; } -void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList& enumList, const AbstractMetaClass* metaClass) +void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass) { if (!metaClass) return; @@ -330,14 +330,14 @@ void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumLi for (const AbstractMetaEnum *metaEnum : enums) { if (metaEnum->isPrivate() || metaEnum->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass) continue; - if (!enumList.contains(const_cast(metaEnum))) - enumList.append(const_cast(metaEnum)); + if (!enumList.contains(const_cast(metaEnum))) + enumList.append(const_cast(metaEnum)); } lookForEnumsInClassesNotToBeGenerated(enumList, metaClass->enclosingClass()); } } -static const AbstractMetaClass* getProperEnclosingClass(const AbstractMetaClass* metaClass) +static const AbstractMetaClass *getProperEnclosingClass(const AbstractMetaClass *metaClass) { if (!metaClass) return 0; @@ -348,12 +348,12 @@ static const AbstractMetaClass* getProperEnclosingClass(const AbstractMetaClass* return getProperEnclosingClass(metaClass->enclosingClass()); } -const AbstractMetaClass* ShibokenGenerator::getProperEnclosingClassForEnum(const AbstractMetaEnum* metaEnum) +const AbstractMetaClass *ShibokenGenerator::getProperEnclosingClassForEnum(const AbstractMetaEnum *metaEnum) { return getProperEnclosingClass(metaEnum->enclosingClass()); } -QString ShibokenGenerator::wrapperName(const AbstractMetaClass* metaClass) const +QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const { if (shouldGenerateCppWrapper(metaClass)) { QString result = metaClass->name(); @@ -403,22 +403,22 @@ QString ShibokenGenerator::fullPythonFunctionName(const AbstractMetaFunction *fu return funcName; } -QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum* metaEnum) +QString ShibokenGenerator::protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum) { return metaEnum->fullName().replace(QLatin1Char('.'), QLatin1Char('_')).replace(QLatin1String("::"), QLatin1String("_")) + QLatin1String("_Surrogate"); } -QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField* field) +QString ShibokenGenerator::protectedFieldGetterName(const AbstractMetaField *field) { return QStringLiteral("protected_%1_getter").arg(field->name()); } -QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField* field) +QString ShibokenGenerator::protectedFieldSetterName(const AbstractMetaField *field) { return QStringLiteral("protected_%1_setter").arg(field->name()); } -QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func) +QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction *func) { QString result; @@ -442,35 +442,35 @@ QString ShibokenGenerator::cpythonFunctionName(const AbstractMetaFunction* func) return result; } -QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunction* func) +QString ShibokenGenerator::cpythonMethodDefinitionName(const AbstractMetaFunction *func) { if (!func->ownerClass()) return QString(); return QStringLiteral("%1Method_%2").arg(cpythonBaseName(func->ownerClass()->typeEntry()), func->name()); } -QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass) + QLatin1String("_getsetlist"); } -QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonSetattroFunctionName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass) + QLatin1String("_setattro"); } -QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonGetattroFunctionName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass) + QLatin1String("_getattro"); } -QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField* metaField) +QString ShibokenGenerator::cpythonGetterFunctionName(const AbstractMetaField *metaField) { return QStringLiteral("%1_get_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name()); } -QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField* metaField) +QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField *metaField) { return QStringLiteral("%1_set_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name()); } @@ -484,7 +484,7 @@ static QString cpythonEnumFlagsName(const QString &moduleName, } // Return the scope for fully qualifying the enumeration including trailing "::". -static QString searchForEnumScope(const AbstractMetaClass* metaClass, const QString& value) +static QString searchForEnumScope(const AbstractMetaClass *metaClass, const QString &value) { if (!metaClass) return QString(); @@ -587,7 +587,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction QString prefix; if (arg->type()->isEnum()) { - if (const AbstractMetaEnum* metaEnum = findAbstractMetaEnum(arg->type())) + if (const AbstractMetaEnum *metaEnum = findAbstractMetaEnum(arg->type())) prefix = resolveScopePrefix(metaEnum, value); } else if (arg->type()->isFlags()) { value = guessScopeForDefaultFlagsValue(func, arg, value); @@ -626,7 +626,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction return value; } -QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry* enumEntry) +QString ShibokenGenerator::cpythonEnumName(const EnumTypeEntry *enumEntry) { QString p = enumEntry->targetLangPackage(); p.replace(QLatin1Char('.'), QLatin1Char('_')); @@ -638,7 +638,7 @@ QString ShibokenGenerator::cpythonEnumName(const AbstractMetaEnum *metaEnum) return cpythonEnumName(metaEnum->typeEntry()); } -QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry* flagsEntry) +QString ShibokenGenerator::cpythonFlagsName(const FlagsTypeEntry *flagsEntry) { QString p = flagsEntry->targetLangPackage(); p.replace(QLatin1Char('.'), QLatin1Char('_')); @@ -653,12 +653,12 @@ QString ShibokenGenerator::cpythonFlagsName(const AbstractMetaEnum *metaEnum) return cpythonFlagsName(flags); } -QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("SpecialCastFunction"); } -QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass* metaClass, +QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass *metaClass, const QString &argName) { return cpythonWrapperCPtr(metaClass->typeEntry(), argName); @@ -674,7 +674,7 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType, + QLatin1String(", reinterpret_cast(") + argName + QLatin1String(")))"); } -QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type, +QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry *type, const QString &argName) { if (!ShibokenGenerator::isWrapperType(type)) @@ -684,31 +684,31 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type, + QLatin1String(", reinterpret_cast(") + argName + QLatin1String(")))"); } -void ShibokenGenerator::writeToPythonConversion(QTextStream & s, const AbstractMetaType* type, +void ShibokenGenerator::writeToPythonConversion(QTextStream & s, const AbstractMetaType *type, const AbstractMetaClass * /* context */, - const QString& argumentName) + const QString &argumentName) { s << cpythonToPythonConversionFunction(type) << argumentName << ')'; } -void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass, - const QString& inArgName, const QString& outArgName) +void ShibokenGenerator::writeToCppConversion(QTextStream &s, const AbstractMetaClass *metaClass, + const QString &inArgName, const QString &outArgName) { s << cpythonToCppConversionFunction(metaClass) << inArgName << ", &" << outArgName << ')'; } -void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaType* type, const AbstractMetaClass* context, - const QString& inArgName, const QString& outArgName) +void ShibokenGenerator::writeToCppConversion(QTextStream &s, const AbstractMetaType *type, const AbstractMetaClass *context, + const QString &inArgName, const QString &outArgName) { s << cpythonToCppConversionFunction(type, context) << inArgName << ", &" << outArgName << ')'; } -bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction* func, int argIndex) +bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex) { if (argIndex < 0 || argIndex >= func->arguments().count()) return false; - const AbstractMetaArgument* arg = func->arguments().at(argIndex); + const AbstractMetaArgument *arg = func->arguments().at(argIndex); if (isValueTypeWithCopyConstructorOnly(arg->type())) return true; @@ -728,7 +728,7 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti return false; } -QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func, bool incRef) const +QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction *func, bool incRef) const { QString result; const char objType = (incRef ? 'O' : 'N'); @@ -772,19 +772,19 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func, return result; } -QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType* type) +QString ShibokenGenerator::cpythonBaseName(const AbstractMetaType *type) { if (isCString(type)) return QLatin1String("PyString"); return cpythonBaseName(type->typeEntry()); } -QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonBaseName(const AbstractMetaClass *metaClass) { return cpythonBaseName(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type) +QString ShibokenGenerator::cpythonBaseName(const TypeEntry *type) { QString baseName; if (ShibokenGenerator::isWrapperType(type) || type->isNamespace()) { // && type->referenceType() == NoReference) { @@ -834,28 +834,28 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry* type) return baseName.replace(QLatin1String("::"), QLatin1String("_")); } -QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonTypeName(const AbstractMetaClass *metaClass) { return cpythonTypeName(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonTypeName(const TypeEntry* type) +QString ShibokenGenerator::cpythonTypeName(const TypeEntry *type) { return cpythonBaseName(type) + QLatin1String("_TypeF()"); } -QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry* type) +QString ShibokenGenerator::cpythonTypeNameExt(const TypeEntry *type) { return cppApiVariableName(type->targetLangPackage()) + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']'); } -QString ShibokenGenerator::converterObject(const AbstractMetaType* type) +QString ShibokenGenerator::converterObject(const AbstractMetaType *type) { if (isCString(type)) - return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter()"); + return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter()"); if (isVoidPointer(type)) - return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter()"); + return QLatin1String("Shiboken::Conversions::PrimitiveTypeConverter()"); const AbstractMetaTypeCList nestedArrayTypes = type->nestedArrayTypes(); if (!nestedArrayTypes.isEmpty() && nestedArrayTypes.constLast()->isCppPrimitive()) { return QStringLiteral("Shiboken::Conversions::ArrayTypeConverter<") @@ -870,7 +870,7 @@ QString ShibokenGenerator::converterObject(const AbstractMetaType* type) return converterObject(type->typeEntry()); } -QString ShibokenGenerator::converterObject(const TypeEntry* type) +QString ShibokenGenerator::converterObject(const TypeEntry *type) { if (isCppPrimitive(type)) return QString::fromLatin1("Shiboken::Conversions::PrimitiveTypeConverter<%1>()").arg(type->qualifiedCppName()); @@ -883,7 +883,7 @@ QString ShibokenGenerator::converterObject(const TypeEntry* type) } /* the typedef'd primitive types case */ - const PrimitiveTypeEntry* pte = dynamic_cast(type); + const PrimitiveTypeEntry *pte = dynamic_cast(type); if (!pte) { qDebug() << "Warning: the Qt5 primitive type is unknown" << type->qualifiedCppName(); return QString(); @@ -897,7 +897,7 @@ QString ShibokenGenerator::converterObject(const TypeEntry* type) + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']'); } -QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType* type) +QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType *type) { return cppApiVariableName(type->typeEntry()->targetLangPackage()) + QLatin1Char('[') + getTypeIndexVariableName(type) + QLatin1Char(']'); @@ -905,13 +905,13 @@ QString ShibokenGenerator::cpythonTypeNameExt(const AbstractMetaType* type) static inline QString unknownOperator() { return QStringLiteral("__UNKNOWN_OPERATOR__"); } -QString ShibokenGenerator::fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative) +QString ShibokenGenerator::fixedCppTypeName(const CustomConversion::TargetToNativeConversion *toNative) { if (toNative->sourceType()) return fixedCppTypeName(toNative->sourceType()); return toNative->sourceTypeName(); } -QString ShibokenGenerator::fixedCppTypeName(const AbstractMetaType* type) +QString ShibokenGenerator::fixedCppTypeName(const AbstractMetaType *type) { return fixedCppTypeName(type->typeEntry(), type->cppSignature()); } @@ -928,7 +928,7 @@ static QString _fixedCppTypeName(QString typeName) typeName.replace(QLatin1String("&"), QLatin1String("REF")); return typeName; } -QString ShibokenGenerator::fixedCppTypeName(const TypeEntry* type, QString typeName) +QString ShibokenGenerator::fixedCppTypeName(const TypeEntry *type, QString typeName) { if (typeName.isEmpty()) typeName = type->qualifiedCppName(); @@ -939,7 +939,7 @@ QString ShibokenGenerator::fixedCppTypeName(const TypeEntry* type, QString typeN return _fixedCppTypeName(typeName); } -QString ShibokenGenerator::pythonPrimitiveTypeName(const QString& cppTypeName) +QString ShibokenGenerator::pythonPrimitiveTypeName(const QString &cppTypeName) { QString rv = ShibokenGenerator::m_pythonPrimitiveTypeName.value(cppTypeName, QString()); if (rv.isEmpty()) { @@ -955,7 +955,7 @@ QString ShibokenGenerator::pythonPrimitiveTypeName(const QString& cppTypeName) return rv; } -QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry* type) +QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry *type) { while (type->basicReferencedTypeEntry()) type = type->basicReferencedTypeEntry(); @@ -972,7 +972,7 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const QString &cppOpFuncNa return value; } -QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction* func) +QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction *func) { QString op = pythonOperatorFunctionName(func->originalName()); if (op == unknownOperator()) @@ -995,7 +995,7 @@ QString ShibokenGenerator::pythonRichCompareOperatorId(const QString &cppOpFuncN return QLatin1String("Py_") + m_pythonOperators.value(cppOpFuncName).toUpper(); } -QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction* func) +QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunction *func) { return pythonRichCompareOperatorId(func->originalName()); } @@ -1008,19 +1008,19 @@ bool ShibokenGenerator::isNumber(const QString &cpythonApiName) || cpythonApiName == QLatin1String("PyBool"); } -bool ShibokenGenerator::isNumber(const TypeEntry* type) +bool ShibokenGenerator::isNumber(const TypeEntry *type) { if (!type->isPrimitive()) return false; return isNumber(pythonPrimitiveTypeName(static_cast(type))); } -bool ShibokenGenerator::isNumber(const AbstractMetaType* type) +bool ShibokenGenerator::isNumber(const AbstractMetaType *type) { return isNumber(type->typeEntry()); } -bool ShibokenGenerator::isPyInt(const TypeEntry* type) +bool ShibokenGenerator::isPyInt(const TypeEntry *type) { if (!type->isPrimitive()) return false; @@ -1028,39 +1028,39 @@ bool ShibokenGenerator::isPyInt(const TypeEntry* type) == QLatin1String("PyInt"); } -bool ShibokenGenerator::isPyInt(const AbstractMetaType* type) +bool ShibokenGenerator::isPyInt(const AbstractMetaType *type) { return isPyInt(type->typeEntry()); } -bool ShibokenGenerator::isWrapperType(const TypeEntry* type) +bool ShibokenGenerator::isWrapperType(const TypeEntry *type) { if (type->isComplex()) return ShibokenGenerator::isWrapperType(static_cast(type)); return type->isObject() || type->isValue() || type->isSmartPointer(); } -bool ShibokenGenerator::isWrapperType(const ComplexTypeEntry* type) +bool ShibokenGenerator::isWrapperType(const ComplexTypeEntry *type) { return isObjectType(type) || type->isValue() || type->isSmartPointer(); } -bool ShibokenGenerator::isWrapperType(const AbstractMetaType* metaType) +bool ShibokenGenerator::isWrapperType(const AbstractMetaType *metaType) { return isObjectType(metaType) || metaType->typeEntry()->isValue() || metaType->typeEntry()->isSmartPointer(); } -bool ShibokenGenerator::isPointerToWrapperType(const AbstractMetaType* type) +bool ShibokenGenerator::isPointerToWrapperType(const AbstractMetaType *type) { return (isObjectType(type) && type->indirections() == 1) || type->isValuePointer(); } -bool ShibokenGenerator::isObjectTypeUsedAsValueType(const AbstractMetaType* type) +bool ShibokenGenerator::isObjectTypeUsedAsValueType(const AbstractMetaType *type) { return type->typeEntry()->isObject() && type->referenceType() == NoReference && type->indirections() == 0; } -bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaClass* metaClass) +bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaClass *metaClass) { if (!metaClass || !metaClass->typeEntry()->isValue()) return false; @@ -1086,21 +1086,21 @@ bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaCla return copyConstructorFound; } -bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry* type) const +bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const { if (!type || !type->isValue()) return false; return isValueTypeWithCopyConstructorOnly(AbstractMetaClass::findClass(classes(), type)); } -bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType* type) const +bool ShibokenGenerator::isValueTypeWithCopyConstructorOnly(const AbstractMetaType *type) const { if (!type || !type->typeEntry()->isValue()) return false; return isValueTypeWithCopyConstructorOnly(type->typeEntry()); } -bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type) +bool ShibokenGenerator::isUserPrimitive(const TypeEntry *type) { if (!type->isPrimitive()) return false; @@ -1111,14 +1111,14 @@ bool ShibokenGenerator::isUserPrimitive(const TypeEntry* type) && trueType->qualifiedCppName() != QLatin1String("std::string"); } -bool ShibokenGenerator::isUserPrimitive(const AbstractMetaType* type) +bool ShibokenGenerator::isUserPrimitive(const AbstractMetaType *type) { if (type->indirections() != 0) return false; return isUserPrimitive(type->typeEntry()); } -bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type) +bool ShibokenGenerator::isCppPrimitive(const TypeEntry *type) { if (type->isCppPrimitive()) return true; @@ -1130,7 +1130,7 @@ bool ShibokenGenerator::isCppPrimitive(const TypeEntry* type) return trueType->qualifiedCppName() == QLatin1String("std::string"); } -bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType* type) +bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType *type) { if (isCString(type) || isVoidPointer(type)) return true; @@ -1139,17 +1139,17 @@ bool ShibokenGenerator::isCppPrimitive(const AbstractMetaType* type) return isCppPrimitive(type->typeEntry()); } -bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument* arg) +bool ShibokenGenerator::shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg) { return shouldDereferenceAbstractMetaTypePointer(arg->type()); } -bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType* metaType) +bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType *metaType) { return metaType->referenceType() == LValueReference && isWrapperType(metaType) && !isPointer(metaType); } -bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction* func) +bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction *func) { const FunctionModificationList &mods = func->modifications(); for (const FunctionModification &mod : mods) { @@ -1159,11 +1159,11 @@ bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction* return false; } -QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType, bool genericNumberType) +QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType *metaType, bool genericNumberType) { QString customCheck; if (metaType->typeEntry()->isCustom()) { - AbstractMetaType* type; + AbstractMetaType *type; customCheck = guessCPythonCheckFunction(metaType->typeEntry()->name(), &type); if (type) metaType = type; @@ -1189,7 +1189,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType || type == ContainerTypeEntry::StackContainer || type == ContainerTypeEntry::SetContainer || type == ContainerTypeEntry::QueueContainer) { - const AbstractMetaType* type = metaType->instantiations().constFirst(); + const AbstractMetaType *type = metaType->instantiations().constFirst(); if (isPointerToWrapperType(type)) { typeCheck += QString::fromLatin1("checkSequenceTypes(%1, ").arg(cpythonTypeNameExt(type)); } else if (isWrapperType(type)) { @@ -1205,8 +1205,8 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType || type == ContainerTypeEntry::MultiHashContainer || type == ContainerTypeEntry::PairContainer) { QString pyType = (type == ContainerTypeEntry::PairContainer) ? QLatin1String("Pair") : QLatin1String("Dict"); - const AbstractMetaType* firstType = metaType->instantiations().constFirst(); - const AbstractMetaType* secondType = metaType->instantiations().constLast(); + const AbstractMetaType *firstType = metaType->instantiations().constFirst(); + const AbstractMetaType *secondType = metaType->instantiations().constLast(); if (isPointerToWrapperType(firstType) && isPointerToWrapperType(secondType)) { typeCheck += QString::fromLatin1("check%1Types(%2, %3, ") .arg(pyType, cpythonTypeNameExt(firstType), cpythonTypeNameExt(secondType)); @@ -1223,11 +1223,11 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType return cpythonCheckFunction(metaType->typeEntry(), genericNumberType); } -QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool genericNumberType) +QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry *type, bool genericNumberType) { QString customCheck; if (type->isCustom()) { - AbstractMetaType* metaType; + AbstractMetaType *metaType; customCheck = guessCPythonCheckFunction(type->name(), &metaType); if (metaType) return cpythonCheckFunction(metaType, genericNumberType); @@ -1250,7 +1250,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool gene return typeCheck; } -QString ShibokenGenerator::guessCPythonCheckFunction(const QString& type, AbstractMetaType** metaType) +QString ShibokenGenerator::guessCPythonCheckFunction(const QString &type, AbstractMetaType **metaType) { *metaType = 0; if (type == QLatin1String("PyTypeObject")) @@ -1269,7 +1269,7 @@ QString ShibokenGenerator::guessCPythonCheckFunction(const QString& type, Abstra return type + QLatin1String("_Check"); } -QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type, +QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry *type, bool /* genericNumberType */, bool /* checkExact */) { @@ -1285,12 +1285,12 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type, return QString::fromLatin1("Shiboken::Conversions::isPythonToCppConvertible(%1, ") .arg(converterObject(type)); } -QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType* metaType, +QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType *metaType, bool /* genericNumberType */) { QString customCheck; if (metaType->typeEntry()->isCustom()) { - AbstractMetaType* type; + AbstractMetaType *type; customCheck = guessCPythonCheckFunction(metaType->typeEntry()->name(), &type); if (type) metaType = type; @@ -1329,7 +1329,7 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaArgume return cpythonIsConvertibleFunction(metaArg->type(), genericNumberType); } -QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass *metaClass) { return QLatin1String("Shiboken::Conversions::pythonToCppPointer(reinterpret_cast(") + cpythonTypeNameExt(metaClass->typeEntry()) + QLatin1String("), "); @@ -1371,12 +1371,12 @@ QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaT (isCString(type) || isVoidPointer(type)) ? QString() : QLatin1String("&")); } -QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass* metaClass) +QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass) { return cpythonToPythonConversionFunction(metaClass->typeEntry()); } -QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry* type) +QString ShibokenGenerator::cpythonToPythonConversionFunction(const TypeEntry *type) { if (isWrapperType(type)) { const QString conversion = type->isValue() ? QLatin1String("copy") : QLatin1String("pointer"); @@ -1463,7 +1463,7 @@ void ShibokenGenerator::writeFunctionArguments(QTextStream &s, } } -QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction* func, Options options) const +QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction *func, Options options) const { QString modifiedReturnType = QString(func->typeReplaced(0)); if (!modifiedReturnType.isEmpty() && !(options & OriginalTypeDescription)) @@ -1530,8 +1530,8 @@ void ShibokenGenerator::writeArgumentNames(QTextStream &s, } } -void ShibokenGenerator::writeFunctionCall(QTextStream& s, - const AbstractMetaFunction* func, +void ShibokenGenerator::writeFunctionCall(QTextStream &s, + const AbstractMetaFunction *func, Options options) const { if (!(options & Generator::SkipName)) @@ -1541,12 +1541,12 @@ void ShibokenGenerator::writeFunctionCall(QTextStream& s, s << ')'; } -void ShibokenGenerator::writeUnusedVariableCast(QTextStream& s, const QString& variableName) +void ShibokenGenerator::writeUnusedVariableCast(QTextStream &s, const QString &variableName) { s << INDENT << "SBK_UNUSED(" << variableName<< ')' << endl; } -AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass* metaClass) +AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass *metaClass) { AbstractMetaFunctionList result; const AbstractMetaFunctionList &funcs = metaClass->functions(); @@ -1572,7 +1572,7 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter for (AbstractMetaFunction *convOp : overloads) { // Get only the conversion operators that return a type from another module, // that are value-types and were not removed in the type system. - const TypeEntry* convType = convOp->type()->typeEntry(); + const TypeEntry *convType = convOp->type()->typeEntry(); if ((convType->codeGeneration() & TypeEntry::GenerateTargetLang) || !convType->isValue() || convOp->isModifiedRemoved()) @@ -1585,7 +1585,7 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter QVector ShibokenGenerator::getPrimitiveCustomConversions() { - QVector conversions; + QVector conversions; const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes(); for (const PrimitiveTypeEntry *type : primitiveTypeList) { if (!shouldGenerateTypeEntry(type) || !isUserPrimitive(type) || !type->customConversion()) @@ -1596,7 +1596,7 @@ QVector ShibokenGenerator::getPrimitiveCustomConversio return conversions; } -static QString getArgumentsFromMethodCall(const QString& str) +static QString getArgumentsFromMethodCall(const QString &str) { // It would be way nicer to be able to use a Perl like // regular expression that accepts temporary variables @@ -1624,7 +1624,7 @@ static QString getArgumentsFromMethodCall(const QString& str) return str.mid(begin, pos-begin-1); } -QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips, +QString ShibokenGenerator::getCodeSnippets(const CodeSnipList &codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language) { @@ -1640,7 +1640,7 @@ QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips, } return code; } -void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass* context) +void ShibokenGenerator::processCodeSnip(QString &code, const AbstractMetaClass *context) { if (context) { // Replace template variable by the Python Type object @@ -1664,16 +1664,16 @@ void ShibokenGenerator::processCodeSnip(QString& code, const AbstractMetaClass* replaceTypeCheckTypeSystemVariable(code); } -ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunction* func, +ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentReplacement(const AbstractMetaFunction *func, bool usePyArgs, TypeSystem::Language language, - const AbstractMetaArgument* lastArg) + const AbstractMetaArgument *lastArg) { ArgumentVarReplacementList argReplacements; TypeSystem::Language convLang = (language == TypeSystem::TargetLangCode) ? TypeSystem::NativeCode : TypeSystem::TargetLangCode; int removed = 0; for (int i = 0; i < func->arguments().size(); ++i) { - const AbstractMetaArgument* arg = func->arguments().at(i); + const AbstractMetaArgument *arg = func->arguments().at(i); QString argValue; if (language == TypeSystem::TargetLangCode) { bool hasConversionRule = !func->conversionRule(convLang, i+1).isEmpty(); @@ -1686,10 +1686,10 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl argValue = QLatin1String(CPP_ARG_REMOVED) + QString::number(i); if (!argRemoved && argValue.isEmpty()) { int argPos = i - removed; - const AbstractMetaType* type = arg->type(); + const AbstractMetaType *type = arg->type(); QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1); if (!typeReplaced.isEmpty()) { - AbstractMetaType* builtType = buildAbstractMetaTypeFromString(typeReplaced); + AbstractMetaType *builtType = buildAbstractMetaTypeFromString(typeReplaced); if (builtType) type = builtType; } @@ -1716,11 +1716,11 @@ ShibokenGenerator::ArgumentVarReplacementList ShibokenGenerator::getArgumentRepl return argReplacements; } -void ShibokenGenerator::writeCodeSnips(QTextStream& s, - const CodeSnipList& codeSnips, +void ShibokenGenerator::writeCodeSnips(QTextStream &s, + const CodeSnipList &codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language, - const AbstractMetaClass* context) + const AbstractMetaClass *context) { QString code = getCodeSnippets(codeSnips, position, language); if (code.isEmpty()) @@ -1731,12 +1731,12 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s, s << INDENT << "// End of code injection" << endl; } -void ShibokenGenerator::writeCodeSnips(QTextStream& s, - const CodeSnipList& codeSnips, +void ShibokenGenerator::writeCodeSnips(QTextStream &s, + const CodeSnipList &codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language, - const AbstractMetaFunction* func, - const AbstractMetaArgument* lastArg) + const AbstractMetaFunction *func, + const AbstractMetaArgument *lastArg) { QString code = getCodeSnippets(codeSnips, position, language); if (code.isEmpty()) @@ -1842,14 +1842,14 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s, QString wrapperClassName = wrapperName(func->ownerClass()); QString cppSelfVar = avoidProtectedHack() ? QLatin1String("%CPPSELF") - : QStringLiteral("reinterpret_cast<%1*>(%CPPSELF)").arg(wrapperClassName); + : QStringLiteral("reinterpret_cast<%1 *>(%CPPSELF)").arg(wrapperClassName); code.replace(pattern, - QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast(%1))" + QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast(%1))" " ? %2->::%3::%FUNCTION_NAME(%4)" " : %CPPSELF.%FUNCTION_NAME(%4))").arg(pySelf, cppSelfVar, wrapperClassName, methodCallArgs)); } else { code.replace(pattern, - QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast(%1))" + QString::fromLatin1("(Shiboken::Object::hasCppWrapper(reinterpret_cast(%1))" " ? %CPPSELF->::%TYPE::%FUNCTION_NAME(%2)" " : %CPPSELF.%FUNCTION_NAME(%2))").arg(pySelf, methodCallArgs)); } @@ -1892,12 +1892,12 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s, code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", "))); for (const ArgumentVarReplacementPair &pair : argReplacements) { - const AbstractMetaArgument* arg = pair.first; + const AbstractMetaArgument *arg = pair.first; int idx = arg->argumentIndex() + 1; - AbstractMetaType* type = arg->type(); + AbstractMetaType *type = arg->type(); QString typeReplaced = func->typeReplaced(arg->argumentIndex() + 1); if (!typeReplaced.isEmpty()) { - AbstractMetaType* builtType = buildAbstractMetaTypeFromString(typeReplaced); + AbstractMetaType *builtType = buildAbstractMetaTypeFromString(typeReplaced); if (builtType) type = builtType; } @@ -1960,7 +1960,7 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s, // Returns true if the string is an expression, // and false if it is a variable. -static bool isVariable(const QString& code) +static bool isVariable(const QString &code) { static const QRegularExpression expr(QStringLiteral("^\\s*\\*?\\s*[A-Za-z_][A-Za-z_0-9.]*\\s*(?:\\[[^\\[]+\\])*$")); Q_ASSERT(expr.isValid()); @@ -1970,7 +1970,7 @@ static bool isVariable(const QString& code) // A miniature normalizer that puts a type string into a format // suitable for comparison with AbstractMetaType::cppSignature() // result. -static QString miniNormalizer(const QString& varType) +static QString miniNormalizer(const QString &varType) { QString normalized = varType.trimmed(); if (normalized.isEmpty()) @@ -1989,7 +1989,7 @@ static QString miniNormalizer(const QString& varType) // The position must indicate the first character after the opening '('. // ATTENTION: do not modify this function to trim any resulting string! // This must be done elsewhere. -static QString getConverterTypeSystemVariableArgument(const QString& code, int pos) +static QString getConverterTypeSystemVariableArgument(const QString &code, int pos) { QString arg; int parenthesisDepth = 0; @@ -2013,7 +2013,7 @@ static QString getConverterTypeSystemVariableArgument(const QString& code, int p } typedef QPair StringPair; -void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code) +void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString &code) { QVector replacements; QRegularExpressionMatchIterator rit = m_typeSystemConvRegEx[converterVariable].globalMatch(code); @@ -2105,7 +2105,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa code.replace(rep.first, rep.second); } -bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func) +bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction *func) { CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode); for (const CodeSnip &snip : qAsConst(snips)) { @@ -2115,7 +2115,7 @@ bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func) return false; } -bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction* func) +bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction *func) { QString funcCall = func->originalName() + QLatin1Char('('); QString wrappedCtorCall; @@ -2135,7 +2135,7 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction* return false; } -bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction* func) +bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFunction *func) { static const QRegularExpression overrideCallRegexCheck(QStringLiteral("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,")); Q_ASSERT(overrideCallRegexCheck.isValid()); @@ -2147,7 +2147,7 @@ bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFuncti return false; } -bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language) +bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMetaFunction *func, TypeSystem::Language language) { static const QRegularExpression retValAttributionRegexCheck_native(QStringLiteral("%0\\s*=[^=]\\s*.+")); Q_ASSERT(retValAttributionRegexCheck_native.isValid()); @@ -2166,7 +2166,7 @@ bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMeta return false; } -bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex) +bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction *func, int argumentIndex) { CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny); const QRegularExpression argRegEx = placeHolderRegex(argumentIndex + 1); @@ -2178,12 +2178,12 @@ bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* fun return false; } -bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass* metaClass) +bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass *metaClass) { return getGeneratorClassInfo(metaClass).needsGetattroFunction; } -bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass* metaClass) +bool ShibokenGenerator::classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass) { if (!metaClass) return false; @@ -2214,7 +2214,7 @@ bool ShibokenGenerator::classNeedsSetattroFunction(const AbstractMetaClass *meta return metaClass->typeEntry()->isSmartPointer(); } -AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass* metaClass) +AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass) { AbstractMetaFunctionList methods; if (metaClass) { @@ -2237,7 +2237,7 @@ AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStatic return methods; } -AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass* metaClass) const +AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass *metaClass) const { AbstractMetaClassList baseClasses; if (metaClass) { @@ -2257,7 +2257,7 @@ AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass* return baseClasses; } -const AbstractMetaClass* ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass* metaClass) +const AbstractMetaClass *ShibokenGenerator::getMultipleInheritingClass(const AbstractMetaClass *metaClass) { if (!metaClass || metaClass->baseClassNames().isEmpty()) return nullptr; @@ -2266,7 +2266,7 @@ const AbstractMetaClass* ShibokenGenerator::getMultipleInheritingClass(const Abs return getMultipleInheritingClass(metaClass->baseClass()); } -AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass* metaClass) const +AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass *metaClass) const { AbstractMetaClassList result; if (metaClass) { @@ -2279,7 +2279,7 @@ AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass return result; } -QString ShibokenGenerator::getModuleHeaderFileName(const QString& moduleName) const +QString ShibokenGenerator::getModuleHeaderFileName(const QString &moduleName) const { return moduleCppPrefix(moduleName).toLower() + QLatin1String("_python.h"); } @@ -2316,14 +2316,14 @@ AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromString(QString typ return it.value(); } -AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const TypeEntry* typeEntry) +AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const TypeEntry *typeEntry) { QString typeName = typeEntry->qualifiedCppName(); if (typeName.startsWith(QLatin1String("::"))) typeName.remove(0, 2); if (m_metaTypeFromStringCache.contains(typeName)) return m_metaTypeFromStringCache.value(typeName); - AbstractMetaType* metaType = new AbstractMetaType; + AbstractMetaType *metaType = new AbstractMetaType; metaType->setTypeEntry(typeEntry); metaType->clearIndirections(); metaType->setReferenceType(NoReference); @@ -2332,7 +2332,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(const Ty m_metaTypeFromStringCache.insert(typeName, metaType); return metaType; } -AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass* metaClass) +AbstractMetaType *ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass *metaClass) { return ShibokenGenerator::buildAbstractMetaTypeFromTypeEntry(metaClass->typeEntry()); } @@ -2354,7 +2354,7 @@ static void dumpFunction(AbstractMetaFunctionList lst) } */ -static bool isGroupable(const AbstractMetaFunction* func) +static bool isGroupable(const AbstractMetaFunction *func) { if (func->isSignal() || func->isDestructor() || (func->isModifiedRemoved() && !func->isAbstract())) return false; @@ -2422,13 +2422,13 @@ ShibokenGenerator::FunctionGroups ShibokenGenerator::getFunctionGroupsImpl(const AbstractMetaFunctionList ShibokenGenerator::getInheritedOverloads(const AbstractMetaFunction *func, QSet *seen) { AbstractMetaFunctionList results; - AbstractMetaClass* basis; + AbstractMetaClass *basis; if (func->ownerClass() && (basis = func->ownerClass()->baseClass())) { for (; basis; basis = basis->baseClass()) { - const AbstractMetaFunction* inFunc = basis->findFunction(func->name()); + const AbstractMetaFunction *inFunc = basis->findFunction(func->name()); if (inFunc && !seen->contains(inFunc->minimalSignature())) { seen->insert(inFunc->minimalSignature()); - AbstractMetaFunction* newFunc = inFunc->copy(); + AbstractMetaFunction *newFunc = inFunc->copy(); newFunc->setImplementingClass(func->implementingClass()); results << newFunc; } @@ -2445,7 +2445,7 @@ AbstractMetaFunctionList ShibokenGenerator::getFunctionAndInheritedOverloads(con return results; } -AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass* scope, const QString& functionName) +AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractMetaClass *scope, const QString &functionName) { AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions(); @@ -2500,24 +2500,24 @@ bool ShibokenGenerator::handleOption(const QString &key, const QString & /* valu return false; } -static void getCode(QStringList& code, const CodeSnipList& codeSnips) +static void getCode(QStringList &code, const CodeSnipList &codeSnips) { for (const CodeSnip &snip : qAsConst(codeSnips)) code.append(snip.code()); } -static void getCode(QStringList& code, const TypeEntry* type) +static void getCode(QStringList &code, const TypeEntry *type) { getCode(code, type->codeSnips()); - CustomConversion* customConversion = type->customConversion(); + CustomConversion *customConversion = type->customConversion(); if (!customConversion) return; if (!customConversion->nativeToTargetConversion().isEmpty()) code.append(customConversion->nativeToTargetConversion()); - const CustomConversion::TargetToNativeConversions& toCppConversions = customConversion->targetToNativeConversions(); + const CustomConversion::TargetToNativeConversions &toCppConversions = customConversion->targetToNativeConversions(); if (toCppConversions.isEmpty()) return; @@ -2556,7 +2556,7 @@ bool ShibokenGenerator::doSetup() return true; } -void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro) +void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro) { QString convMacro = toPythonMacro ? QLatin1String("%CONVERTTOPYTHON[") : QLatin1String("%CONVERTTOCPP["); int offset = toPythonMacro ? sizeof("%CONVERTTOPYTHON") : sizeof("%CONVERTTOCPP"); @@ -2566,7 +2566,7 @@ void ShibokenGenerator::collectContainerTypesFromConverterMacros(const QString& start += offset; if (code.at(start) != QLatin1Char('%')) { QString typeString = code.mid(start, end - start); - AbstractMetaType* type = buildAbstractMetaTypeFromString(typeString); + AbstractMetaType *type = buildAbstractMetaTypeFromString(typeString); addInstantiatedContainersAndSmartPointers(type, type->originalTypeDescription()); } start = end; @@ -2598,26 +2598,26 @@ bool ShibokenGenerator::avoidProtectedHack() const return m_avoidProtectedHack; } -QString ShibokenGenerator::moduleCppPrefix(const QString& moduleName) const +QString ShibokenGenerator::moduleCppPrefix(const QString &moduleName) const { QString result = moduleName.isEmpty() ? packageName() : moduleName; result.replace(QLatin1Char('.'), QLatin1Char('_')); return result; } -QString ShibokenGenerator::cppApiVariableName(const QString& moduleName) const +QString ShibokenGenerator::cppApiVariableName(const QString &moduleName) const { return QLatin1String("Sbk") + moduleCppPrefix(moduleName) + QLatin1String("Types"); } -QString ShibokenGenerator::pythonModuleObjectName(const QString& moduleName) const +QString ShibokenGenerator::pythonModuleObjectName(const QString &moduleName) const { return QLatin1String("Sbk") + moduleCppPrefix(moduleName) + QLatin1String("ModuleObject"); } -QString ShibokenGenerator::convertersVariableName(const QString& moduleName) const +QString ShibokenGenerator::convertersVariableName(const QString &moduleName) const { QString result = cppApiVariableName(moduleName); result.chop(1); @@ -2625,7 +2625,7 @@ QString ShibokenGenerator::convertersVariableName(const QString& moduleName) con return result; } -static QString processInstantiationsVariableName(const AbstractMetaType* type) +static QString processInstantiationsVariableName(const AbstractMetaType *type) { QString res = QLatin1Char('_') + _fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper(); const AbstractMetaTypeList &instantiations = type->instantiations(); @@ -2644,10 +2644,10 @@ static void appendIndexSuffix(QString *s) s->append(QStringLiteral("IDX")); } -QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* metaClass, bool alternativeTemplateName) +QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass *metaClass, bool alternativeTemplateName) { if (alternativeTemplateName) { - const AbstractMetaClass* templateBaseClass = metaClass->templateBaseClass(); + const AbstractMetaClass *templateBaseClass = metaClass->templateBaseClass(); if (!templateBaseClass) return QString(); QString result = QLatin1String("SBK_") @@ -2660,10 +2660,10 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* met } return getTypeIndexVariableName(metaClass->typeEntry()); } -QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type) +QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry *type) { if (type->isCppPrimitive()) { - const PrimitiveTypeEntry *trueType = static_cast(type); + const PrimitiveTypeEntry *trueType = static_cast(type); if (trueType->basicReferencedTypeEntry()) type = trueType->basicReferencedTypeEntry(); } @@ -2678,7 +2678,7 @@ QString ShibokenGenerator::getTypeIndexVariableName(const TypeEntry* type) appendIndexSuffix(&result); return result; } -QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType* type) +QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaType *type) { QString result = QLatin1String("SBK"); if (type->typeEntry()->isContainer()) @@ -2693,7 +2693,7 @@ bool ShibokenGenerator::verboseErrorMessagesDisabled() const return m_verboseErrorMessagesDisabled; } -bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData) +bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadData &overloadData) { if (overloadData.referenceFunction()->isCallOperator()) return true; @@ -2707,7 +2707,7 @@ bool ShibokenGenerator::pythonFunctionWrapperUsesListOfArguments(const OverloadD || overloadData.hasArgumentWithDefaultValue(); } -QString ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg) +QString ShibokenGenerator::getDefaultValue(const AbstractMetaFunction *func, const AbstractMetaArgument *arg) { if (!arg->defaultValueExpression().isEmpty()) return arg->defaultValueExpression(); @@ -2723,7 +2723,7 @@ QString ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, co return QString(); } -void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const AbstractMetaType* type, const QString& defaultCtor) +void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream &s, const AbstractMetaType *type, const QString &defaultCtor) { if (!defaultCtor.isEmpty()) { s << " = " << defaultCtor; @@ -2741,7 +2741,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const } } -void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const TypeEntry* type, const QString& defaultCtor) +void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream &s, const TypeEntry *type, const QString &defaultCtor) { if (!defaultCtor.isEmpty()) { s << " = " << defaultCtor; @@ -2759,7 +2759,7 @@ void ShibokenGenerator::writeMinimalConstructorExpression(QTextStream& s, const } } -bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type) +bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry *type) { if (!type->isCppPrimitive()) return false; @@ -2771,7 +2771,7 @@ bool ShibokenGenerator::isCppIntegralPrimitive(const TypeEntry* type) && !typeName.contains(QLatin1String("float")) && !typeName.contains(QLatin1String("wchar")); } -bool ShibokenGenerator::isCppIntegralPrimitive(const AbstractMetaType* type) +bool ShibokenGenerator::isCppIntegralPrimitive(const AbstractMetaType *type) { return isCppIntegralPrimitive(type->typeEntry()); } diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h index f5f291526..fe6a1dc37 100644 --- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h +++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h @@ -74,16 +74,16 @@ public: /** * Helper function to find for argument default value */ - static QString getDefaultValue(const AbstractMetaFunction* func, const AbstractMetaArgument* arg); + static QString getDefaultValue(const AbstractMetaFunction *func, const AbstractMetaArgument *arg); /// Returns a list of all ancestor classes for the given class. - AbstractMetaClassList getAllAncestors(const AbstractMetaClass* metaClass) const; + AbstractMetaClassList getAllAncestors(const AbstractMetaClass *metaClass) const; protected: bool doSetup() override; void writeArgumentNames(QTextStream &s, - const AbstractMetaFunction* func, + const AbstractMetaFunction *func, Options options = NoOption) const override; /** @@ -94,7 +94,7 @@ protected: * \param options some extra options used during the parser */ void writeFunctionArguments(QTextStream &s, - const AbstractMetaFunction* func, + const AbstractMetaFunction *func, Options options = NoOption) const override; /** @@ -114,21 +114,21 @@ protected: AbstractMetaFunctionList getFunctionAndInheritedOverloads(const AbstractMetaFunction *func, QSet *seen); /// Write user's custom code snippets at class or module level. - void writeCodeSnips(QTextStream& s, + void writeCodeSnips(QTextStream &s, const QVector & codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language, - const AbstractMetaClass* context = 0); + const AbstractMetaClass *context = 0); /// Write user's custom code snippets at function level. - void writeCodeSnips(QTextStream& s, + void writeCodeSnips(QTextStream &s, const QVector & codeSnips, TypeSystem::CodeSnipPosition position, TypeSystem::Language language, - const AbstractMetaFunction* func, - const AbstractMetaArgument* lastArg = 0); + const AbstractMetaFunction *func, + const AbstractMetaArgument *lastArg = nullptr); /// Replaces variables for the user's custom code at global or class level. - void processCodeSnip(QString& code, const AbstractMetaClass* context = 0); + void processCodeSnip(QString &code, const AbstractMetaClass *context = nullptr); /** * Verifies if any of the function's code injections of the "native" @@ -136,7 +136,7 @@ protected: * \param func the function to check * \return true if the function's native code snippets use "%PYSELF" */ - bool injectedCodeUsesPySelf(const AbstractMetaFunction* func); + bool injectedCodeUsesPySelf(const AbstractMetaFunction *func); /** * Verifies if any of the function's code injections makes a call @@ -145,7 +145,7 @@ protected: * \param func the function to check * \return true if the function's code snippets call the wrapped C++ function */ - bool injectedCodeCallsCppFunction(const AbstractMetaFunction* func); + bool injectedCodeCallsCppFunction(const AbstractMetaFunction *func); /** * Verifies if any of the function's code injections of the "native" class makes a @@ -154,7 +154,7 @@ protected: * \param func the function to check * \return true if the function's code snippets call the Python override for a C++ virtual method */ - bool injectedCodeCallsPythonOverride(const AbstractMetaFunction* func); + bool injectedCodeCallsPythonOverride(const AbstractMetaFunction *func); /** * Verifies if any of the function's code injections attributes values to @@ -163,13 +163,13 @@ protected: * \param language the kind of code snip * \return true if the function's code attributes values to "%0" or "%PYARG_0" */ - bool injectedCodeHasReturnValueAttribution(const AbstractMetaFunction* func, TypeSystem::Language language = TypeSystem::TargetLangCode); + bool injectedCodeHasReturnValueAttribution(const AbstractMetaFunction *func, TypeSystem::Language language = TypeSystem::TargetLangCode); /** * Verifies if any of the function's code injections uses the type system variable * for function arguments of a given index. */ - bool injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex); + bool injectedCodeUsesArgument(const AbstractMetaFunction *func, int argumentIndex); /** * Function which parse the metafunction information @@ -177,125 +177,125 @@ protected: * \param option some extra options * \param arg_count the number of function arguments */ - QString functionSignature(const AbstractMetaFunction* func, + QString functionSignature(const AbstractMetaFunction *func, const QString &prepend = QString(), const QString &append = QString(), Options options = NoOption, int arg_count = -1) const; /// Returns the top-most class that has multiple inheritance in the ancestry. - static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass* metaClass); + static const AbstractMetaClass *getMultipleInheritingClass(const AbstractMetaClass *metaClass); /// Returns true if the class needs to have a getattro function. - bool classNeedsGetattroFunction(const AbstractMetaClass* metaClass); + bool classNeedsGetattroFunction(const AbstractMetaClass *metaClass); /// Returns true if the class needs to have a setattro function. bool classNeedsSetattroFunction(const AbstractMetaClass *metaClass); /// Returns a list of methods of the given class where each one is part of a different overload with both static and non-static method. - AbstractMetaFunctionList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass* metaClass); + AbstractMetaFunctionList getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass *metaClass); /// Returns a list of parent classes for a given class. - AbstractMetaClassList getBaseClasses(const AbstractMetaClass* metaClass) const; + AbstractMetaClassList getBaseClasses(const AbstractMetaClass *metaClass) const; - void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type, - const AbstractMetaClass* context, const QString& argumentName); - void writeToCppConversion(QTextStream& s, const AbstractMetaType* type, const AbstractMetaClass* context, const QString& inArgName, const QString& outArgName); - void writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass, const QString& inArgName, const QString& outArgName); + void writeToPythonConversion(QTextStream &s, const AbstractMetaType *type, + const AbstractMetaClass *context, const QString &argumentName); + void writeToCppConversion(QTextStream &s, const AbstractMetaType *type, const AbstractMetaClass *context, const QString &inArgName, const QString &outArgName); + void writeToCppConversion(QTextStream &s, const AbstractMetaClass *metaClass, const QString &inArgName, const QString &outArgName); /// Returns true if the argument is a pointer that rejects nullptr values. - bool shouldRejectNullPointerArgument(const AbstractMetaFunction* func, int argIndex); + bool shouldRejectNullPointerArgument(const AbstractMetaFunction *func, int argIndex); /// Verifies if the class should have a C++ wrapper generated for it, instead of only a Python wrapper. - bool shouldGenerateCppWrapper(const AbstractMetaClass* metaClass) const; + bool shouldGenerateCppWrapper(const AbstractMetaClass *metaClass) const; /// Adds enums eligible for generation from classes/namespaces marked not to be generated. - static void lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList& enumList, const AbstractMetaClass* metaClass); + static void lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass); /// Returns the enclosing class for an enum, or nullptr if it should be global. - const AbstractMetaClass* getProperEnclosingClassForEnum(const AbstractMetaEnum* metaEnum); + const AbstractMetaClass *getProperEnclosingClassForEnum(const AbstractMetaEnum *metaEnum); - QString wrapperName(const AbstractMetaClass* metaClass) const; + QString wrapperName(const AbstractMetaClass *metaClass) const; QString wrapperName(const AbstractMetaType *metaType) const; QString fullPythonClassName(const AbstractMetaClass *metaClass); QString fullPythonFunctionName(const AbstractMetaFunction *func); - static QString protectedEnumSurrogateName(const AbstractMetaEnum* metaEnum); - static QString protectedFieldGetterName(const AbstractMetaField* field); - static QString protectedFieldSetterName(const AbstractMetaField* field); + static QString protectedEnumSurrogateName(const AbstractMetaEnum *metaEnum); + static QString protectedFieldGetterName(const AbstractMetaField *field); + static QString protectedFieldSetterName(const AbstractMetaField *field); - static QString pythonPrimitiveTypeName(const QString& cppTypeName); - static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry* type); + static QString pythonPrimitiveTypeName(const QString &cppTypeName); + static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry *type); static QString pythonOperatorFunctionName(const QString &cppOpFuncName); - static QString pythonOperatorFunctionName(const AbstractMetaFunction* func); + static QString pythonOperatorFunctionName(const AbstractMetaFunction *func); static QString pythonRichCompareOperatorId(const QString &cppOpFuncName); - static QString pythonRichCompareOperatorId(const AbstractMetaFunction* func); + static QString pythonRichCompareOperatorId(const AbstractMetaFunction *func); - static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative); - static QString fixedCppTypeName(const AbstractMetaType* type); - static QString fixedCppTypeName(const TypeEntry* type, QString typeName = QString()); + static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion *toNative); + static QString fixedCppTypeName(const AbstractMetaType *type); + static QString fixedCppTypeName(const TypeEntry *type, QString typeName = QString()); static bool isNumber(const QString &cpythonApiName); - static bool isNumber(const TypeEntry* type); - static bool isNumber(const AbstractMetaType* type); - static bool isPyInt(const TypeEntry* type); - static bool isPyInt(const AbstractMetaType* type); + static bool isNumber(const TypeEntry *type); + static bool isNumber(const AbstractMetaType *type); + static bool isPyInt(const TypeEntry *type); + static bool isPyInt(const AbstractMetaType *type); /** * Returns true if the type passed has a Python wrapper for it. * Although namespace has a Python wrapper, it's not considered a type. */ - static bool isWrapperType(const TypeEntry* type); - static bool isWrapperType(const ComplexTypeEntry* type); - static bool isWrapperType(const AbstractMetaType* metaType); + static bool isWrapperType(const TypeEntry *type); + static bool isWrapperType(const ComplexTypeEntry *type); + static bool isWrapperType(const AbstractMetaType *metaType); /** * Checks if the type is an Object/QObject or pointer to Value Type. * In other words, tells if the type is "T*" and T has a Python wrapper. */ - static bool isPointerToWrapperType(const AbstractMetaType* type); + static bool isPointerToWrapperType(const AbstractMetaType *type); /** * Returns true if \p type is an Object Type used as a value. */ - static bool isObjectTypeUsedAsValueType(const AbstractMetaType* type); + static bool isObjectTypeUsedAsValueType(const AbstractMetaType *type); - static bool isValueTypeWithCopyConstructorOnly(const AbstractMetaClass* metaClass); - bool isValueTypeWithCopyConstructorOnly(const TypeEntry* type) const; - bool isValueTypeWithCopyConstructorOnly(const AbstractMetaType* type) const; + static bool isValueTypeWithCopyConstructorOnly(const AbstractMetaClass *metaClass); + bool isValueTypeWithCopyConstructorOnly(const TypeEntry *type) const; + bool isValueTypeWithCopyConstructorOnly(const AbstractMetaType *type) const; /// Returns true if the type is a primitive but not a C++ primitive. - static bool isUserPrimitive(const TypeEntry* type); - static bool isUserPrimitive(const AbstractMetaType* type); + static bool isUserPrimitive(const TypeEntry *type); + static bool isUserPrimitive(const AbstractMetaType *type); /// Returns true if the type is a C++ primitive, a void*, a const char*, or a std::string. - static bool isCppPrimitive(const TypeEntry* type); - static bool isCppPrimitive(const AbstractMetaType* type); + static bool isCppPrimitive(const TypeEntry *type); + static bool isCppPrimitive(const AbstractMetaType *type); /// Returns true if the type is a C++ integral primitive, i.e. bool, char, int, long, and their unsigned counterparts. - static bool isCppIntegralPrimitive(const TypeEntry* type); - static bool isCppIntegralPrimitive(const AbstractMetaType* type); + static bool isCppIntegralPrimitive(const TypeEntry *type); + static bool isCppIntegralPrimitive(const AbstractMetaType *type); /// Checks if an argument type should be dereferenced by the Python method wrapper before calling the C++ method. - static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument* arg); + static bool shouldDereferenceArgumentPointer(const AbstractMetaArgument *arg); /// Checks if a meta type should be dereferenced by the Python method wrapper passing it to C++. - static bool shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType* metaType); - - static bool visibilityModifiedToPrivate(const AbstractMetaFunction* func); - - QString converterObject(const AbstractMetaType* type); - QString converterObject(const TypeEntry* type); - - QString cpythonBaseName(const AbstractMetaClass* metaClass); - QString cpythonBaseName(const TypeEntry* type); - QString cpythonBaseName(const AbstractMetaType* type); - QString cpythonTypeName(const AbstractMetaClass* metaClass); - QString cpythonTypeName(const TypeEntry* type); - QString cpythonTypeNameExt(const TypeEntry* type); - QString cpythonTypeNameExt(const AbstractMetaType* type); - QString cpythonCheckFunction(const TypeEntry* type, bool genericNumberType = false); - QString cpythonCheckFunction(const AbstractMetaType* metaType, bool genericNumberType = false); + static bool shouldDereferenceAbstractMetaTypePointer(const AbstractMetaType *metaType); + + static bool visibilityModifiedToPrivate(const AbstractMetaFunction *func); + + QString converterObject(const AbstractMetaType *type); + QString converterObject(const TypeEntry *type); + + QString cpythonBaseName(const AbstractMetaClass *metaClass); + QString cpythonBaseName(const TypeEntry *type); + QString cpythonBaseName(const AbstractMetaType *type); + QString cpythonTypeName(const AbstractMetaClass *metaClass); + QString cpythonTypeName(const TypeEntry *type); + QString cpythonTypeNameExt(const TypeEntry *type); + QString cpythonTypeNameExt(const AbstractMetaType *type); + QString cpythonCheckFunction(const TypeEntry *type, bool genericNumberType = false); + QString cpythonCheckFunction(const AbstractMetaType *metaType, bool genericNumberType = false); /** * Receives the argument \p type and tries to find the appropriate AbstractMetaType for it * or a custom type check. @@ -306,28 +306,28 @@ protected: * \return A custom check if \p type is a custom type, or an empty string if \p metaType * receives an existing type object. */ - QString guessCPythonCheckFunction(const QString& type, AbstractMetaType** metaType); - QString cpythonIsConvertibleFunction(const TypeEntry* type, bool genericNumberType = false, bool checkExact = false); - QString cpythonIsConvertibleFunction(const AbstractMetaType* metaType, bool genericNumberType = false); - QString cpythonIsConvertibleFunction(const AbstractMetaArgument* metaArg, bool genericNumberType = false); - - QString cpythonToCppConversionFunction(const AbstractMetaClass* metaClass); - QString cpythonToCppConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0); - QString cpythonToPythonConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0); - QString cpythonToPythonConversionFunction(const AbstractMetaClass* metaClass); - QString cpythonToPythonConversionFunction(const TypeEntry* type); - - QString cpythonFunctionName(const AbstractMetaFunction* func); - QString cpythonMethodDefinitionName(const AbstractMetaFunction* func); - QString cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass); - QString cpythonGetattroFunctionName(const AbstractMetaClass* metaClass); - QString cpythonSetattroFunctionName(const AbstractMetaClass* metaClass); - QString cpythonGetterFunctionName(const AbstractMetaField* metaField); - QString cpythonSetterFunctionName(const AbstractMetaField* metaField); - QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass, + QString guessCPythonCheckFunction(const QString &type, AbstractMetaType **metaType); + QString cpythonIsConvertibleFunction(const TypeEntry *type, bool genericNumberType = false, bool checkExact = false); + QString cpythonIsConvertibleFunction(const AbstractMetaType *metaType, bool genericNumberType = false); + QString cpythonIsConvertibleFunction(const AbstractMetaArgument *metaArg, bool genericNumberType = false); + + QString cpythonToCppConversionFunction(const AbstractMetaClass *metaClass); + QString cpythonToCppConversionFunction(const AbstractMetaType *type, const AbstractMetaClass *context = 0); + QString cpythonToPythonConversionFunction(const AbstractMetaType *type, const AbstractMetaClass *context = 0); + QString cpythonToPythonConversionFunction(const AbstractMetaClass *metaClass); + QString cpythonToPythonConversionFunction(const TypeEntry *type); + + QString cpythonFunctionName(const AbstractMetaFunction *func); + QString cpythonMethodDefinitionName(const AbstractMetaFunction *func); + QString cpythonGettersSettersDefinitionName(const AbstractMetaClass *metaClass); + QString cpythonGetattroFunctionName(const AbstractMetaClass *metaClass); + QString cpythonSetattroFunctionName(const AbstractMetaClass *metaClass); + QString cpythonGetterFunctionName(const AbstractMetaField *metaField); + QString cpythonSetterFunctionName(const AbstractMetaField *metaField); + QString cpythonWrapperCPtr(const AbstractMetaClass *metaClass, const QString &argName = QLatin1String("self")); QString cpythonWrapperCPtr(const AbstractMetaType *metaType, const QString &argName); - QString cpythonWrapperCPtr(const TypeEntry* type, const QString &argName); + QString cpythonWrapperCPtr(const TypeEntry *type, const QString &argName); /// Guesses the scope to where belongs an argument's default value. QString guessScopeForDefaultValue(const AbstractMetaFunction *func, @@ -336,18 +336,18 @@ protected: const AbstractMetaArgument *arg, const QString &value) const; - QString cpythonEnumName(const EnumTypeEntry* enumEntry); - QString cpythonEnumName(const AbstractMetaEnum* metaEnum); + QString cpythonEnumName(const EnumTypeEntry *enumEntry); + QString cpythonEnumName(const AbstractMetaEnum *metaEnum); - QString cpythonFlagsName(const FlagsTypeEntry* flagsEntry); - QString cpythonFlagsName(const AbstractMetaEnum* metaEnum); + QString cpythonFlagsName(const FlagsTypeEntry *flagsEntry); + QString cpythonFlagsName(const AbstractMetaEnum *metaEnum); /// Returns the special cast function name, the function used to proper cast class with multiple inheritance. - QString cpythonSpecialCastFunctionName(const AbstractMetaClass* metaClass); + QString cpythonSpecialCastFunctionName(const AbstractMetaClass *metaClass); - QString getFormatUnitString(const AbstractMetaFunction* func, bool incRef = false) const; + QString getFormatUnitString(const AbstractMetaFunction *func, bool incRef = false) const; /// Returns the file name for the module global header. If no module name is provided the current will be used. - QString getModuleHeaderFileName(const QString& moduleName = QString()) const; + QString getModuleHeaderFileName(const QString &moduleName = QString()) const; OptionDescriptions options() const override; bool handleOption(const QString &key, const QString &value) override; @@ -362,18 +362,18 @@ protected: bool useIsNullAsNbNonZero() const; /// Returns true if the generated code should use the "#define protected public" hack. bool avoidProtectedHack() const; - QString cppApiVariableName(const QString& moduleName = QString()) const; - QString pythonModuleObjectName(const QString& moduleName = QString()) const; - QString convertersVariableName(const QString& moduleName = QString()) const; + QString cppApiVariableName(const QString &moduleName = QString()) const; + QString pythonModuleObjectName(const QString &moduleName = QString()) const; + QString convertersVariableName(const QString &moduleName = QString()) const; /** * Returns the type index variable name for a given class. If \p alternativeTemplateName is true * and the class is a typedef for a template class instantiation, it will return an alternative name * made of the template class and the instantiation values, or an empty string if the class isn't * derived from a template class at all. */ - QString getTypeIndexVariableName(const AbstractMetaClass* metaClass, bool alternativeTemplateName = false); - QString getTypeIndexVariableName(const TypeEntry* type); - QString getTypeIndexVariableName(const AbstractMetaType* type); + QString getTypeIndexVariableName(const AbstractMetaClass *metaClass, bool alternativeTemplateName = false); + QString getTypeIndexVariableName(const TypeEntry *type); + QString getTypeIndexVariableName(const AbstractMetaType *type); /// Returns true if the user don't want verbose error messages on the generated bindings. bool verboseErrorMessagesDisabled() const; @@ -389,16 +389,16 @@ protected: QString *errorMessage = nullptr); /// Creates an AbstractMetaType object from a TypeEntry. - AbstractMetaType* buildAbstractMetaTypeFromTypeEntry(const TypeEntry* typeEntry); + AbstractMetaType *buildAbstractMetaTypeFromTypeEntry(const TypeEntry *typeEntry); /// Creates an AbstractMetaType object from an AbstractMetaClass. - AbstractMetaType* buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass* metaClass); + AbstractMetaType *buildAbstractMetaTypeFromAbstractMetaClass(const AbstractMetaClass *metaClass); - void writeMinimalConstructorExpression(QTextStream& s, const AbstractMetaType* type, const QString& defaultCtor = QString()); - void writeMinimalConstructorExpression(QTextStream& s, const TypeEntry* type, const QString& defaultCtor = QString()); + void writeMinimalConstructorExpression(QTextStream &s, const AbstractMetaType *type, const QString &defaultCtor = QString()); + void writeMinimalConstructorExpression(QTextStream &s, const TypeEntry *type, const QString &defaultCtor = QString()); - void collectContainerTypesFromConverterMacros(const QString& code, bool toPythonMacro); + void collectContainerTypesFromConverterMacros(const QString &code, bool toPythonMacro); // verify whether the class is copyable - bool isCopyable(const AbstractMetaClass* metaClass); + bool isCopyable(const AbstractMetaClass *metaClass); void clearTpFuncs(); @@ -408,13 +408,13 @@ protected: /// Initializes a list of Python known type names. static void initKnownPythonTypes(); - void writeFunctionCall(QTextStream& s, - const AbstractMetaFunction* metaFunc, + void writeFunctionCall(QTextStream &s, + const AbstractMetaFunction *metaFunc, Options options = NoOption) const; - void writeUnusedVariableCast(QTextStream& s, const QString& variableName); + void writeUnusedVariableCast(QTextStream &s, const QString &variableName); - AbstractMetaFunctionList filterFunctions(const AbstractMetaClass* metaClass); + AbstractMetaFunctionList filterFunctions(const AbstractMetaClass *metaClass); // All data about extended converters: the type entries of the target type, and a // list of AbstractMetaClasses accepted as argument for the conversion. @@ -426,7 +426,7 @@ protected: QVector getPrimitiveCustomConversions(); /// Returns true if the Python wrapper for the received OverloadData must accept a list of arguments. - static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData); + static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData &overloadData); Indentor INDENT; @@ -446,8 +446,8 @@ private: static FunctionGroups getFunctionGroupsImpl(const AbstractMetaClass *scope); static bool classNeedsGetattroFunctionImpl(const AbstractMetaClass *metaClass); - QString translateTypeForWrapperMethod(const AbstractMetaType* cType, - const AbstractMetaClass* context, + QString translateTypeForWrapperMethod(const AbstractMetaType *cType, + const AbstractMetaClass *context, Options opt = NoOption) const; /** @@ -464,8 +464,8 @@ private: * \param scope scope used to search for overloads. * \param functionName the function name. */ - AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass* scope, - const QString& functionName); + AbstractMetaFunctionList getFunctionOverloads(const AbstractMetaClass *scope, + const QString &functionName); /** * Write a function argument in the C++ in the text stream \p s. * This function just call \code s << argumentString(); \endcode @@ -475,8 +475,8 @@ private: * \param options some extra options. */ void writeArgument(QTextStream &s, - const AbstractMetaFunction* func, - const AbstractMetaArgument* argument, + const AbstractMetaFunction *func, + const AbstractMetaArgument *argument, Options options = NoOption) const; /** * Create a QString in the C++ format to an function argument. @@ -484,18 +484,18 @@ private: * \param argument metaargument information to be parsed. * \param options some extra options. */ - QString argumentString(const AbstractMetaFunction* func, - const AbstractMetaArgument* argument, + QString argumentString(const AbstractMetaFunction *func, + const AbstractMetaArgument *argument, Options options = NoOption) const; - QString functionReturnType(const AbstractMetaFunction* func, Options options = NoOption) const; + QString functionReturnType(const AbstractMetaFunction *func, Options options = NoOption) const; /// Utility function for writeCodeSnips. - typedef QPair ArgumentVarReplacementPair; + typedef QPair ArgumentVarReplacementPair; typedef QVector ArgumentVarReplacementList; - ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func, + ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction *func, bool usePyArgs, TypeSystem::Language language, - const AbstractMetaArgument* lastArg); + const AbstractMetaArgument *lastArg); /// Returns a string with the user's custom code snippets that comply with \p position and \p language. QString getCodeSnippets(const QVector & codeSnips, @@ -509,31 +509,31 @@ private: TypeSystemToPythonFunction, TypeSystemConverterVariables }; - void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code); + void replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString &code); /// Replaces the %CONVERTTOPYTHON type system variable. - inline void replaceConvertToPythonTypeSystemVariable(QString& code) + inline void replaceConvertToPythonTypeSystemVariable(QString &code) { replaceConverterTypeSystemVariable(TypeSystemToPythonFunction, code); } /// Replaces the %CONVERTTOCPP type system variable. - inline void replaceConvertToCppTypeSystemVariable(QString& code) + inline void replaceConvertToCppTypeSystemVariable(QString &code) { replaceConverterTypeSystemVariable(TypeSystemToCppFunction, code); } /// Replaces the %ISCONVERTIBLE type system variable. - inline void replaceIsConvertibleToCppTypeSystemVariable(QString& code) + inline void replaceIsConvertibleToCppTypeSystemVariable(QString &code) { replaceConverterTypeSystemVariable(TypeSystemIsConvertibleFunction, code); } /// Replaces the %CHECKTYPE type system variable. - inline void replaceTypeCheckTypeSystemVariable(QString& code) + inline void replaceTypeCheckTypeSystemVariable(QString &code) { replaceConverterTypeSystemVariable(TypeSystemCheckFunction, code); } /// Return a prefix with '_' suitable for names in C++ - QString moduleCppPrefix(const QString& moduleName = QString()) const; + QString moduleCppPrefix(const QString &moduleName = QString()) const; bool m_useCtorHeuristic = false; bool m_userReturnValueHeuristic = false; @@ -542,7 +542,7 @@ private: bool m_useIsNullAsNbNonZero = false; bool m_avoidProtectedHack = false; - typedef QHash AbstractMetaTypeCache; + typedef QHash AbstractMetaTypeCache; AbstractMetaTypeCache m_metaTypeFromStringCache; /// Type system converter variable replacement names and regular expressions. diff --git a/sources/shiboken2/libshiboken/autodecref.h b/sources/shiboken2/libshiboken/autodecref.h index 72fd236de..b2f5a6325 100644 --- a/sources/shiboken2/libshiboken/autodecref.h +++ b/sources/shiboken2/libshiboken/autodecref.h @@ -53,21 +53,21 @@ namespace Shiboken struct LIBSHIBOKEN_API AutoDecRef { public: - AutoDecRef(const AutoDecRef&) = delete; - AutoDecRef(AutoDecRef&&) = delete; - AutoDecRef& operator=(const AutoDecRef&) = delete; - AutoDecRef& operator=(AutoDecRef&&) = delete; + AutoDecRef(const AutoDecRef &) = delete; + AutoDecRef(AutoDecRef &&) = delete; + AutoDecRef &operator=(const AutoDecRef &) = delete; + AutoDecRef &operator=(AutoDecRef &&) = delete; /** * AutoDecRef constructor. * \param pyobj A borrowed reference to a Python object */ - explicit AutoDecRef(PyObject* pyObj) : m_pyObj(pyObj) {} + explicit AutoDecRef(PyObject *pyObj) : m_pyObj(pyObj) {} /** * AutoDecRef constructor. * \param pyobj A borrowed reference to a Python object */ - explicit AutoDecRef(SbkObject* pyObj) : m_pyObj(reinterpret_cast(pyObj)) {} + explicit AutoDecRef(SbkObject *pyObj) : m_pyObj(reinterpret_cast(pyObj)) {} /// Decref the borrowed python reference ~AutoDecRef() @@ -77,13 +77,13 @@ public: inline bool isNull() const { return m_pyObj == 0; } /// Returns the pointer of the Python object being held. - inline PyObject* object() { return m_pyObj; } - inline operator PyObject*() { return m_pyObj; } + inline PyObject *object() { return m_pyObj; } + inline operator PyObject *() { return m_pyObj; } #ifndef Py_LIMITED_API - inline operator PyTupleObject*() { return reinterpret_cast(m_pyObj); } + inline operator PyTupleObject *() { return reinterpret_cast(m_pyObj); } #endif inline operator bool() const { return m_pyObj != 0; } - inline PyObject* operator->() { return m_pyObj; } + inline PyObject *operator->() { return m_pyObj; } template T cast() @@ -94,13 +94,13 @@ public: /** * Decref the current borrowed python reference and borrow \p other. */ - void reset(PyObject* other) + void reset(PyObject *other) { Py_XDECREF(m_pyObj); m_pyObj = other; } private: - PyObject* m_pyObj; + PyObject *m_pyObj; }; } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/basewrapper.cpp b/sources/shiboken2/libshiboken/basewrapper.cpp index f38b55b56..a12d95982 100644 --- a/sources/shiboken2/libshiboken/basewrapper.cpp +++ b/sources/shiboken2/libshiboken/basewrapper.cpp @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of Qt for Python. @@ -58,7 +58,7 @@ #include "voidptr.h" namespace { - void _destroyParentInfo(SbkObject* obj, bool keepReference); + void _destroyParentInfo(SbkObject *obj, bool keepReference); } static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEntries &dts) @@ -73,15 +73,15 @@ static void callDestructor(const Shiboken::DtorAccumulatorVisitor::DestructorEnt extern "C" { -static void SbkObjectTypeDealloc(PyObject* pyObj); -static PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds); +static void SbkObjectTypeDealloc(PyObject *pyObj); +static PyObject *SbkObjectTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds); // PYSIDE-908: The function PyType_Modified does not work in PySide, so we need to // explicitly pass __doc__. For __signature__ it _did_ actually work, because // it was not existing before. We add them both for clarity. static PyGetSetDef SbkObjectType_Type_getsetlist[] = { - {const_cast("__signature__"), (getter)Sbk_TypeGet___signature__}, - {const_cast("__doc__"), (getter)Sbk_TypeGet___doc__}, + {const_cast("__signature__"), (getter)Sbk_TypeGet___signature__}, + {const_cast("__doc__"), (getter)Sbk_TypeGet___doc__}, {nullptr} // Sentinel }; @@ -205,7 +205,7 @@ PyTypeObject *SbkObjectType_TypeF(void) return type; } -static PyObject *SbkObjectGetDict(PyObject* pObj, void *) +static PyObject *SbkObjectGetDict(PyObject *pObj, void *) { SbkObject *obj = reinterpret_cast(pObj); if (!obj->ob_dict) @@ -217,23 +217,23 @@ static PyObject *SbkObjectGetDict(PyObject* pObj, void *) } static PyGetSetDef SbkObjectGetSetList[] = { - {const_cast("__dict__"), SbkObjectGetDict, 0, 0, 0}, + {const_cast("__dict__"), SbkObjectGetDict, 0, 0, 0}, {0, 0, 0, 0, 0} // Sentinel }; -static int SbkObject_traverse(PyObject* self, visitproc visit, void* arg) +static int SbkObject_traverse(PyObject *self, visitproc visit, void *arg) { - SbkObject* sbkSelf = reinterpret_cast(self); + SbkObject *sbkSelf = reinterpret_cast(self); //Visit children - Shiboken::ParentInfo* pInfo = sbkSelf->d->parentInfo; + Shiboken::ParentInfo *pInfo = sbkSelf->d->parentInfo; if (pInfo) { for (SbkObject *c : pInfo->children) Py_VISIT(c); } //Visit refs - Shiboken::RefCountMap* rInfo = sbkSelf->d->referredObjects; + Shiboken::RefCountMap *rInfo = sbkSelf->d->referredObjects; if (rInfo) { for (auto it = rInfo->begin(), end = rInfo->end(); it != end; ++it) Py_VISIT(it->second); @@ -244,9 +244,9 @@ static int SbkObject_traverse(PyObject* self, visitproc visit, void* arg) return 0; } -static int SbkObject_clear(PyObject* self) +static int SbkObject_clear(PyObject *self) { - SbkObject* sbkSelf = reinterpret_cast(self); + SbkObject *sbkSelf = reinterpret_cast(self); Shiboken::Object::removeParent(sbkSelf); @@ -298,10 +298,10 @@ static int mainThreadDeletionHandler(void *) return 0; } -static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete) +static void SbkDeallocWrapperCommon(PyObject *pyObj, bool canDelete) { - SbkObject* sbkObj = reinterpret_cast(pyObj); - PyTypeObject* pyType = Py_TYPE(pyObj); + SbkObject *sbkObj = reinterpret_cast(pyObj); + PyTypeObject *pyType = Py_TYPE(pyObj); // Need to decref the type if this is the dealloc func; if type // is subclassed, that dealloc func will decref (see subtype_dealloc @@ -352,7 +352,7 @@ static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete) Shiboken::Object::deallocData(sbkObj, true); callDestructor(visitor.entries()); } else { - void* cptr = sbkObj->d->cptr[0]; + void *cptr = sbkObj->d->cptr[0]; Shiboken::Object::deallocData(sbkObj, true); Shiboken::ThreadStateSaver threadSaver; @@ -368,27 +368,27 @@ static void SbkDeallocWrapperCommon(PyObject* pyObj, bool canDelete) Py_DECREF(pyType); } -void SbkDeallocWrapper(PyObject* pyObj) +void SbkDeallocWrapper(PyObject *pyObj) { SbkDeallocWrapperCommon(pyObj, true); } -void SbkDeallocQAppWrapper(PyObject* pyObj) +void SbkDeallocQAppWrapper(PyObject *pyObj) { SbkDeallocWrapper(pyObj); // PYSIDE-571: make sure to create a singleton deleted qApp. MakeSingletonQAppWrapper(NULL); } -void SbkDeallocWrapperWithPrivateDtor(PyObject* self) +void SbkDeallocWrapperWithPrivateDtor(PyObject *self) { SbkDeallocWrapperCommon(self, false); } -void SbkObjectTypeDealloc(PyObject* pyObj) +void SbkObjectTypeDealloc(PyObject *pyObj) { SbkObjectTypePrivate *sotp = PepType_SOTP(pyObj); - PyTypeObject *type = reinterpret_cast(pyObj); + auto type = reinterpret_cast(pyObj); PyObject_GC_UnTrack(pyObj); #ifndef Py_LIMITED_API @@ -411,7 +411,7 @@ void SbkObjectTypeDealloc(PyObject* pyObj) #endif } -PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds) +PyObject *SbkObjectTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds) { // Check if all bases are new style before calling type.tp_new // Was causing gc assert errors in test_bug704.py when @@ -422,19 +422,19 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k // Before we changed to heap types, it was sufficient to remove the // Py_TPFLAGS_BASETYPE flag. That does not work, because PySide does // not respect this flag itself! - PyObject* name; - PyObject* pyBases; - PyObject* dict; - static const char* kwlist[] = { "name", "bases", "dict", 0}; + PyObject *name; + PyObject *pyBases; + PyObject *dict; + static const char *kwlist[] = { "name", "bases", "dict", nullptr}; - if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!O!:sbktype", (char**)kwlist, + if (!PyArg_ParseTupleAndKeywords(args, kwds, "sO!O!:sbktype", (char **)kwlist, &name, &PyTuple_Type, &pyBases, &PyDict_Type, &dict)) return NULL; for (int i=0, i_max=PyTuple_GET_SIZE(pyBases); i < i_max; i++) { - PyObject* baseType = PyTuple_GET_ITEM(pyBases, i); + PyObject *baseType = PyTuple_GET_ITEM(pyBases, i); #ifndef IS_PY3K if (PyClass_Check(baseType)) { PyErr_Format(PyExc_TypeError, "Invalid base class used in type %s. " @@ -450,14 +450,14 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k // The meta type creates a new type when the Python programmer extends a wrapped C++ class. newfunc type_new = reinterpret_cast(PyType_Type.tp_new); - SbkObjectType *newType = reinterpret_cast(type_new(metatype, args, kwds)); + SbkObjectType *newType = reinterpret_cast(type_new(metatype, args, kwds)); if (!newType) return 0; Shiboken::ObjectType::initPrivateData(newType); SbkObjectTypePrivate *sotp = PepType_SOTP(newType); - const auto bases = Shiboken::getCppBaseClasses(reinterpret_cast(newType)); + const auto bases = Shiboken::getCppBaseClasses(reinterpret_cast(newType)); if (bases.size() == 1) { SbkObjectTypePrivate *parentType = PepType_SOTP(bases.front()); sotp->mi_offsets = parentType->mi_offsets; @@ -489,19 +489,19 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k PepType_SOTP(base)->subtype_init(newType, args, kwds); } - return reinterpret_cast(newType); + return reinterpret_cast(newType); } static PyObject *_setupNew(SbkObject *self, PyTypeObject *subtype) { - Py_INCREF(reinterpret_cast(subtype)); - SbkObjectPrivate* d = new SbkObjectPrivate; + Py_INCREF(reinterpret_cast(subtype)); + auto d = new SbkObjectPrivate; - SbkObjectTypePrivate * sotp = PepType_SOTP(subtype); + SbkObjectTypePrivate *sotp = PepType_SOTP(subtype); int numBases = ((sotp && sotp->is_multicpp) ? Shiboken::getNumberOfCppBaseClasses(subtype) : 1); - d->cptr = new void*[numBases]; - std::memset(d->cptr, 0, sizeof(void*) * size_t(numBases)); + d->cptr = new void *[numBases]; + std::memset(d->cptr, 0, sizeof(void *) *size_t(numBases)); d->hasOwnership = 1; d->containsCppWrapper = 0; d->validCppObject = 0; @@ -511,18 +511,18 @@ static PyObject *_setupNew(SbkObject *self, PyTypeObject *subtype) self->ob_dict = nullptr; self->weakreflist = nullptr; self->d = d; - return reinterpret_cast(self); + return reinterpret_cast(self); } -PyObject* SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *) +PyObject *SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *) { SbkObject *self = PyObject_GC_New(SbkObject, subtype); PyObject *res = _setupNew(self, subtype); - PyObject_GC_Track(reinterpret_cast(self)); + PyObject_GC_Track(reinterpret_cast(self)); return res; } -PyObject* SbkQAppTpNew(PyTypeObject* subtype, PyObject *, PyObject *) +PyObject *SbkQAppTpNew(PyTypeObject *subtype, PyObject *, PyObject *) { // PYSIDE-571: // For qApp, we need to create a singleton Python object. @@ -542,7 +542,7 @@ PyObject* SbkQAppTpNew(PyTypeObject* subtype, PyObject *, PyObject *) subtype->tp_free = PyObject_Del; } #endif - SbkObject* self = reinterpret_cast(MakeSingletonQAppWrapper(subtype)); + auto self = reinterpret_cast(MakeSingletonQAppWrapper(subtype)); return self == 0 ? 0 : _setupNew(self, subtype); } @@ -553,7 +553,7 @@ object_dealloc(PyObject *self) } PyObject * -SbkDummyNew(PyTypeObject *type, PyObject*, PyObject*) +SbkDummyNew(PyTypeObject *type, PyObject *, PyObject *) { // PYSIDE-595: Give the same error as type_call does when tp_new is NULL. PyErr_Format(PyExc_TypeError, @@ -568,12 +568,12 @@ SbkDummyNew(PyTypeObject *type, PyObject*, PyObject*) namespace { -void _destroyParentInfo(SbkObject* obj, bool keepReference) +void _destroyParentInfo(SbkObject *obj, bool keepReference) { - Shiboken::ParentInfo* pInfo = obj->d->parentInfo; + Shiboken::ParentInfo *pInfo = obj->d->parentInfo; if (pInfo) { while(!pInfo->children.empty()) { - SbkObject* first = *pInfo->children.begin(); + SbkObject *first = *pInfo->children.begin(); // Mark child as invalid Shiboken::Object::invalidate(first); Shiboken::Object::removeParent(first, false, keepReference); @@ -588,13 +588,13 @@ namespace Shiboken { bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor) { - PyObject* bases = currentType->tp_bases; + PyObject *bases = currentType->tp_bases; Py_ssize_t numBases = PyTuple_GET_SIZE(bases); bool result = false; for (int i = 0; !result && i < numBases; ++i) { - PyTypeObject* type = reinterpret_cast(PyTuple_GET_ITEM(bases, i)); - if (PyType_IsSubtype(type, reinterpret_cast(SbkObject_TypeF()))) { - SbkObjectType* sbkType = reinterpret_cast(type); + auto type = reinterpret_cast(PyTuple_GET_ITEM(bases, i)); + if (PyType_IsSubtype(type, reinterpret_cast(SbkObject_TypeF()))) { + auto sbkType = reinterpret_cast(type); result = PepType_SOTP(sbkType)->is_user_type ? walkThroughClassHierarchy(type, visitor) : visitor->visit(sbkType); } @@ -602,10 +602,10 @@ bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visi return result; } -bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr) +bool importModule(const char *moduleName, PyTypeObject *** cppApiPtr) { - PyObject* sysModules = PyImport_GetModuleDict(); - PyObject* module = PyDict_GetItemString(sysModules, moduleName); + PyObject *sysModules = PyImport_GetModuleDict(); + PyObject *module = PyDict_GetItemString(sysModules, moduleName); if (!module) { module = PyImport_ImportModule(moduleName); if (!module) @@ -622,11 +622,11 @@ bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr) #ifdef IS_PY3K if (PyCapsule_CheckExact(cppApi)) - *cppApiPtr = reinterpret_cast(PyCapsule_GetPointer(cppApi, 0)); + *cppApiPtr = reinterpret_cast(PyCapsule_GetPointer(cppApi, 0)); #else // Python 2.6 doesn't have PyCapsule API, so let's keep usign PyCObject on all Python 2.x if (PyCObject_Check(cppApi)) - *cppApiPtr = reinterpret_cast(PyCObject_AsVoidPtr(cppApi)); + *cppApiPtr = reinterpret_cast(PyCObject_AsVoidPtr(cppApi)); #endif return true; } @@ -651,7 +651,7 @@ bool BaseAccumulatorVisitor::visit(SbkObjectType *node) bool GetIndexVisitor::visit(SbkObjectType *node) { m_index++; - return PyType_IsSubtype(reinterpret_cast(node), m_desiredType); + return PyType_IsSubtype(reinterpret_cast(node), m_desiredType); } bool DtorAccumulatorVisitor::visit(SbkObjectType *node) @@ -709,27 +709,27 @@ public: bool visit(SbkObjectType *node) override { - return reinterpret_cast(node) == m_typeToFind; + return reinterpret_cast(node) == m_typeToFind; } private: PyTypeObject *m_typeToFind; }; -std::vector splitPyObject(PyObject* pyObj) +std::vector splitPyObject(PyObject *pyObj) { std::vector result; if (PySequence_Check(pyObj)) { AutoDecRef lst(PySequence_Fast(pyObj, "Invalid keep reference object.")); if (!lst.isNull()) { for (Py_ssize_t i = 0, i_max = PySequence_Fast_GET_SIZE(lst.object()); i < i_max; ++i) { - PyObject* item = PySequence_Fast_GET_ITEM(lst.object(), i); + PyObject *item = PySequence_Fast_GET_ITEM(lst.object(), i); if (Object::checkType(item)) - result.push_back(reinterpret_cast(item)); + result.push_back(reinterpret_cast(item)); } } } else { - result.push_back(reinterpret_cast(pyObj)); + result.push_back(reinterpret_cast(pyObj)); } return result; } @@ -744,17 +744,17 @@ inline void decRefPyObjectList(Iterator i1, Iterator i2) namespace ObjectType { -bool checkType(PyTypeObject* type) +bool checkType(PyTypeObject *type) { - return PyType_IsSubtype(type, reinterpret_cast(SbkObject_TypeF())) != 0; + return PyType_IsSubtype(type, reinterpret_cast(SbkObject_TypeF())) != 0; } -bool isUserType(PyTypeObject* type) +bool isUserType(PyTypeObject *type) { return checkType(type) && PepType_SOTP(type)->is_user_type; } -bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType) +bool canCallConstructor(PyTypeObject *myType, PyTypeObject *ctorType) { FindBaseTypeVisitor visitor(ctorType); if (!walkThroughClassHierarchy(myType, &visitor)) { @@ -764,23 +764,23 @@ bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType) return true; } -bool hasCast(SbkObjectType* type) +bool hasCast(SbkObjectType *type) { return PepType_SOTP(type)->mi_specialcast != 0; } -void* cast(SbkObjectType* sourceType, SbkObject* obj, PyTypeObject* targetType) +void *cast(SbkObjectType *sourceType, SbkObject *obj, PyTypeObject *targetType) { return PepType_SOTP(sourceType)->mi_specialcast(Object::cppPointer(obj, targetType), - reinterpret_cast(targetType)); + reinterpret_cast(targetType)); } -void setCastFunction(SbkObjectType* type, SpecialCastFunction func) +void setCastFunction(SbkObjectType *type, SpecialCastFunction func) { PepType_SOTP(type)->mi_specialcast = func; } -void setOriginalName(SbkObjectType* type, const char* name) +void setOriginalName(SbkObjectType *type, const char *name) { SbkObjectTypePrivate *sotp = PepType_SOTP(type); if (sotp->original_name) @@ -788,12 +788,12 @@ void setOriginalName(SbkObjectType* type, const char* name) sotp->original_name = strdup(name); } -const char* getOriginalName(SbkObjectType* type) +const char *getOriginalName(SbkObjectType *type) { return PepType_SOTP(type)->original_name; } -void setTypeDiscoveryFunctionV2(SbkObjectType* type, TypeDiscoveryFuncV2 func) +void setTypeDiscoveryFunctionV2(SbkObjectType *type, TypeDiscoveryFuncV2 func) { PepType_SOTP(type)->type_discovery = func; } @@ -805,7 +805,7 @@ void copyMultipleInheritance(SbkObjectType *type, SbkObjectType *other) PepType_SOTP(type)->mi_specialcast = PepType_SOTP(other)->mi_specialcast; } -void setMultipleInheritanceFunction(SbkObjectType* type, MultipleInheritanceInitFunction function) +void setMultipleInheritanceFunction(SbkObjectType *type, MultipleInheritanceInitFunction function) { PepType_SOTP(type)->mi_init = function; } @@ -815,12 +815,12 @@ MultipleInheritanceInitFunction getMultipleInheritanceFunction(SbkObjectType *ty return PepType_SOTP(type)->mi_init; } -void setDestructorFunction(SbkObjectType* type, ObjectDestructor func) +void setDestructorFunction(SbkObjectType *type, ObjectDestructor func) { PepType_SOTP(type)->cpp_dtor = func; } -void initPrivateData(SbkObjectType* type) +void initPrivateData(SbkObjectType *type) { PepType_SOTP(type) = new SbkObjectTypePrivate; memset(PepType_SOTP(type), 0, sizeof(SbkObjectTypePrivate)); @@ -872,17 +872,17 @@ introduceWrapperType(PyObject *enclosingObject, return PyModule_AddObject(enclosingObject, typeName, ob_type) == 0 ? type : nullptr; } -void setSubTypeInitHook(SbkObjectType* type, SubTypeInitHook func) +void setSubTypeInitHook(SbkObjectType *type, SubTypeInitHook func) { PepType_SOTP(type)->subtype_init = func; } -void* getTypeUserData(SbkObjectType* type) +void *getTypeUserData(SbkObjectType *type) { return PepType_SOTP(type)->user_data; } -void setTypeUserData(SbkObjectType* type, void* userData, DeleteUserDataFunc d_func) +void setTypeUserData(SbkObjectType *type, void *userData, DeleteUserDataFunc d_func) { SbkObjectTypePrivate *sotp = PepType_SOTP(type); sotp->user_data = userData; @@ -895,7 +895,7 @@ SbkObjectType *typeForTypeName(const char *typeName) SbkObjectType *result{}; if (typeName) { if (PyTypeObject *pyType = Shiboken::Conversions::getPythonTypeObject(typeName)) - result = reinterpret_cast(pyType); + result = reinterpret_cast(pyType); } return result; } @@ -912,25 +912,25 @@ bool hasSpecialCastFunction(SbkObjectType *sbkType) namespace Object { -static void recursive_invalidate(SbkObject* self, std::set& seen); +static void recursive_invalidate(SbkObject *self, std::set& seen); -bool checkType(PyObject* pyObj) +bool checkType(PyObject *pyObj) { return ObjectType::checkType(Py_TYPE(pyObj)); } -bool isUserType(PyObject* pyObj) +bool isUserType(PyObject *pyObj) { return ObjectType::isUserType(Py_TYPE(pyObj)); } -Py_hash_t hash(PyObject* pyObj) +Py_hash_t hash(PyObject *pyObj) { assert(Shiboken::Object::checkType(pyObj)); return reinterpret_cast(pyObj); } -static void setSequenceOwnership(PyObject* pyObj, bool owner) +static void setSequenceOwnership(PyObject *pyObj, bool owner) { bool has_length = true; @@ -957,36 +957,36 @@ static void setSequenceOwnership(PyObject* pyObj, bool owner) } } else if (Object::checkType(pyObj)) { if (owner) - getOwnership(reinterpret_cast(pyObj)); + getOwnership(reinterpret_cast(pyObj)); else - releaseOwnership(reinterpret_cast(pyObj)); + releaseOwnership(reinterpret_cast(pyObj)); } } -void setValidCpp(SbkObject* pyObj, bool value) +void setValidCpp(SbkObject *pyObj, bool value) { pyObj->d->validCppObject = value; } -void setHasCppWrapper(SbkObject* pyObj, bool value) +void setHasCppWrapper(SbkObject *pyObj, bool value) { pyObj->d->containsCppWrapper = value; } -bool hasCppWrapper(SbkObject* pyObj) +bool hasCppWrapper(SbkObject *pyObj) { return pyObj->d->containsCppWrapper; } -bool wasCreatedByPython(SbkObject* pyObj) +bool wasCreatedByPython(SbkObject *pyObj) { return pyObj->d->cppObjectCreated; } -void callCppDestructors(SbkObject* pyObj) +void callCppDestructors(SbkObject *pyObj) { PyTypeObject *type = Py_TYPE(pyObj); - SbkObjectTypePrivate * sotp = PepType_SOTP(type); + SbkObjectTypePrivate *sotp = PepType_SOTP(type); if (sotp->is_multicpp) { Shiboken::DtorAccumulatorVisitor visitor(pyObj); Shiboken::walkThroughClassHierarchy(type, &visitor); @@ -1011,12 +1011,12 @@ void callCppDestructors(SbkObject* pyObj) pyObj->d->validCppObject = false; } -bool hasOwnership(SbkObject* pyObj) +bool hasOwnership(SbkObject *pyObj) { return pyObj->d->hasOwnership; } -void getOwnership(SbkObject* self) +void getOwnership(SbkObject *self) { // skip if already have the ownership if (self->d->hasOwnership) @@ -1035,16 +1035,16 @@ void getOwnership(SbkObject* self) makeValid(self); // Make the object valid again } -void getOwnership(PyObject* pyObj) +void getOwnership(PyObject *pyObj) { if (pyObj) setSequenceOwnership(pyObj, true); } -void releaseOwnership(SbkObject* self) +void releaseOwnership(SbkObject *self) { // skip if the ownership have already moved to c++ - SbkObjectType* selfType = reinterpret_cast(Py_TYPE(self)); + SbkObjectType *selfType = reinterpret_cast(Py_TYPE(self)); if (!self->d->hasOwnership || Shiboken::Conversions::pythonTypeIsValueType(PepType_SOTP(selfType)->converter)) return; @@ -1058,35 +1058,35 @@ void releaseOwnership(SbkObject* self) invalidate(self); // If I do not know when this object will die We need to invalidate this to avoid use after } -void releaseOwnership(PyObject* self) +void releaseOwnership(PyObject *self) { setSequenceOwnership(self, false); } /* Needed forward declarations */ -static void recursive_invalidate(PyObject* pyobj, std::set& seen); -static void recursive_invalidate(SbkObject* self, std::set& seen); +static void recursive_invalidate(PyObject *pyobj, std::set& seen); +static void recursive_invalidate(SbkObject *self, std::set &seen); -void invalidate(PyObject* pyobj) +void invalidate(PyObject *pyobj) { - std::set seen; + std::set seen; recursive_invalidate(pyobj, seen); } -void invalidate(SbkObject* self) +void invalidate(SbkObject *self) { - std::set seen; + std::set seen; recursive_invalidate(self, seen); } -static void recursive_invalidate(PyObject* pyobj, std::set& seen) +static void recursive_invalidate(PyObject *pyobj, std::set &seen) { const auto objs = splitPyObject(pyobj); for (SbkObject *o : objs) recursive_invalidate(o, seen); } -static void recursive_invalidate(SbkObject* self, std::set& seen) +static void recursive_invalidate(SbkObject *self, std::set &seen) { // Skip if this object not is a valid object or if it's already been seen if (!self || reinterpret_cast(self) == Py_None || seen.find(self) != seen.end()) @@ -1115,13 +1115,13 @@ static void recursive_invalidate(SbkObject* self, std::set& seen) // If has ref to other objects invalidate all if (self->d->referredObjects) { - RefCountMap& refCountMap = *(self->d->referredObjects); + RefCountMap &refCountMap = *(self->d->referredObjects); for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it) recursive_invalidate(it->second, seen); } } -void makeValid(SbkObject* self) +void makeValid(SbkObject *self) { // Skip if this object not is a valid object if (!self || reinterpret_cast(self) == Py_None || self->d->validCppObject) @@ -1138,7 +1138,7 @@ void makeValid(SbkObject* self) // If has ref to other objects make all valid again if (self->d->referredObjects) { - RefCountMap& refCountMap = *(self->d->referredObjects); + RefCountMap &refCountMap = *(self->d->referredObjects); RefCountMap::iterator iter; for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it) { if (Shiboken::Object::checkType(it->second)) @@ -1147,28 +1147,28 @@ void makeValid(SbkObject* self) } } -void* cppPointer(SbkObject* pyObj, PyTypeObject* desiredType) +void *cppPointer(SbkObject *pyObj, PyTypeObject *desiredType) { - PyTypeObject* type = Py_TYPE(pyObj); + PyTypeObject *type = Py_TYPE(pyObj); int idx = 0; - if (PepType_SOTP(reinterpret_cast(type))->is_multicpp) + if (PepType_SOTP(reinterpret_cast(type))->is_multicpp) idx = getTypeIndexOnHierarchy(type, desiredType); if (pyObj->d->cptr) return pyObj->d->cptr[idx]; return 0; } -std::vector cppPointers(SbkObject* pyObj) +std::vector cppPointers(SbkObject *pyObj) { int n = getNumberOfCppBaseClasses(Py_TYPE(pyObj)); - std::vector ptrs(n); + std::vector ptrs(n); for (int i = 0; i < n; ++i) ptrs[i] = pyObj->d->cptr[i]; return ptrs; } -bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr) +bool setCppPointer(SbkObject *sbkObj, PyTypeObject *desiredType, void *cptr) { int idx = 0; PyTypeObject *type = Py_TYPE(sbkObj); @@ -1185,14 +1185,14 @@ bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr) return !alreadyInitialized; } -bool isValid(PyObject* pyObj) +bool isValid(PyObject *pyObj) { if (!pyObj || pyObj == Py_None || Py_TYPE(Py_TYPE(pyObj)) != SbkObjectType_TypeF()) { return true; } - SbkObjectPrivate* priv = reinterpret_cast(pyObj)->d; + auto priv = reinterpret_cast(pyObj)->d; if (!priv->cppObjectCreated && isUserType(pyObj)) { PyErr_Format(PyExc_RuntimeError, "'__init__' method of object's base class (%s) not called.", @@ -1209,13 +1209,13 @@ bool isValid(PyObject* pyObj) return true; } -bool isValid(SbkObject* pyObj, bool throwPyError) +bool isValid(SbkObject *pyObj, bool throwPyError) { if (!pyObj) return false; - SbkObjectPrivate* priv = pyObj->d; - if (!priv->cppObjectCreated && isUserType(reinterpret_cast(pyObj))) { + SbkObjectPrivate *priv = pyObj->d; + if (!priv->cppObjectCreated && isUserType(reinterpret_cast(pyObj))) { if (throwPyError) PyErr_Format(PyExc_RuntimeError, "Base constructor of the object (%s) not called.", Py_TYPE(pyObj)->tp_name); @@ -1232,13 +1232,13 @@ bool isValid(SbkObject* pyObj, bool throwPyError) return true; } -bool isValid(PyObject* pyObj, bool throwPyError) +bool isValid(PyObject *pyObj, bool throwPyError) { if (!pyObj || pyObj == Py_None || - !PyType_IsSubtype(Py_TYPE(pyObj), reinterpret_cast(SbkObject_TypeF()))) { + !PyType_IsSubtype(Py_TYPE(pyObj), reinterpret_cast(SbkObject_TypeF()))) { return true; } - return isValid(reinterpret_cast(pyObj), throwPyError); + return isValid(reinterpret_cast(pyObj), throwPyError); } SbkObject *findColocatedChild(SbkObject *wrapper, @@ -1251,11 +1251,11 @@ SbkObject *findColocatedChild(SbkObject *wrapper, if (!(wrapper->d && wrapper->d->cptr)) return 0; - ParentInfo* pInfo = wrapper->d->parentInfo; + ParentInfo *pInfo = wrapper->d->parentInfo; if (!pInfo) return 0; - ChildrenList& children = pInfo->children; + ChildrenList &children = pInfo->children; for (SbkObject *child : children) { if (!(child->d && child->d->cptr)) @@ -1270,11 +1270,11 @@ SbkObject *findColocatedChild(SbkObject *wrapper, return 0; } -PyObject *newObject(SbkObjectType* instanceType, - void* cptr, +PyObject *newObject(SbkObjectType *instanceType, + void *cptr, bool hasOwnership, bool isExactType, - const char* typeName) + const char *typeName) { // Try to find the exact type of cptr. if (!isExactType) { @@ -1286,11 +1286,11 @@ PyObject *newObject(SbkObjectType* instanceType, bool shouldCreate = true; bool shouldRegister = true; - SbkObject* self = 0; + SbkObject *self = 0; // Some logic to ensure that colocated child field does not overwrite the parent if (BindingManager::instance().hasWrapper(cptr)) { - SbkObject* existingWrapper = BindingManager::instance().retrieveWrapper(cptr); + SbkObject *existingWrapper = BindingManager::instance().retrieveWrapper(cptr); self = findColocatedChild(existingWrapper, instanceType); if (self) { @@ -1313,7 +1313,7 @@ PyObject *newObject(SbkObjectType* instanceType, } if (shouldCreate) { - self = reinterpret_cast(SbkObjectTpNew(reinterpret_cast(instanceType), 0, 0)); + self = reinterpret_cast(SbkObjectTpNew(reinterpret_cast(instanceType), 0, 0)); self->d->cptr[0] = cptr; self->d->hasOwnership = hasOwnership; self->d->validCppObject = 1; @@ -1321,17 +1321,17 @@ PyObject *newObject(SbkObjectType* instanceType, BindingManager::instance().registerWrapper(self, cptr); } } else { - Py_IncRef(reinterpret_cast(self)); + Py_IncRef(reinterpret_cast(self)); } - return reinterpret_cast(self); + return reinterpret_cast(self); } -void destroy(SbkObject* self) +void destroy(SbkObject *self) { destroy(self, 0); } -void destroy(SbkObject* self, void* cppData) +void destroy(SbkObject *self, void *cppData) { // Skip if this is called with NULL pointer this can happen in derived classes if (!self) @@ -1375,9 +1375,9 @@ void destroy(SbkObject* self, void* cppData) // After this point the object can be death do not use the self pointer bellow } -void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference) +void removeParent(SbkObject *child, bool giveOwnershipBack, bool keepReference) { - ParentInfo* pInfo = child->d->parentInfo; + ParentInfo *pInfo = child->d->parentInfo; if (!pInfo || !pInfo->parent) { if (pInfo && pInfo->hasWrapperRef) { pInfo->hasWrapperRef = false; @@ -1385,7 +1385,7 @@ void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference) return; } - ChildrenList& oldBrothers = pInfo->parent->d->parentInfo->children; + ChildrenList &oldBrothers = pInfo->parent->d->parentInfo->children; // Verify if this child is part of parent list auto iChild = oldBrothers.find(child); if (iChild == oldBrothers.end()) @@ -1413,18 +1413,18 @@ void removeParent(SbkObject* child, bool giveOwnershipBack, bool keepReference) Py_DECREF(child); } -void setParent(PyObject* parent, PyObject* child) +void setParent(PyObject *parent, PyObject *child) { if (!child || child == Py_None || child == parent) return; /* - * setParent is recursive when the child is a native Python sequence, i.e. objects not binded by Shiboken - * like tuple and list. + * setParent is recursive when the child is a native Python sequence, i.e. objects not binded by Shiboken + * like tuple and list. * - * This "limitation" exists to fix the following problem: A class multiple inherits QObject and QString, - * so if you pass this class to someone that takes the ownership, we CAN'T enter in this if, but hey! QString - * follows the sequence protocol. + * This "limitation" exists to fix the following problem: A class multiple inherits QObject and QString, + * so if you pass this class to someone that takes the ownership, we CAN'T enter in this if, but hey! QString + * follows the sequence protocol. */ if (PySequence_Check(child) && !Object::checkType(child)) { Shiboken::AutoDecRef seq(PySequence_Fast(child, 0)); @@ -1434,8 +1434,8 @@ void setParent(PyObject* parent, PyObject* child) } bool parentIsNull = !parent || parent == Py_None; - SbkObject* parent_ = reinterpret_cast(parent); - SbkObject* child_ = reinterpret_cast(child); + auto parent_ = reinterpret_cast(parent); + auto child_ = reinterpret_cast(child); if (!parentIsNull) { if (!parent_->d->parentInfo) @@ -1446,7 +1446,7 @@ void setParent(PyObject* parent, PyObject* child) return; } - ParentInfo* pInfo = child_->d->parentInfo; + ParentInfo *pInfo = child_->d->parentInfo; bool hasAnotherParent = pInfo && pInfo->parent && pInfo->parent != parent_; //Avoid destroy child during reparent operation @@ -1476,7 +1476,7 @@ void setParent(PyObject* parent, PyObject* child) Py_DECREF(child); } -void deallocData(SbkObject* self, bool cleanup) +void deallocData(SbkObject *self, bool cleanup) { // Make cleanup if this is not a wrapper otherwise this will be done on wrapper destructor if(cleanup) { @@ -1499,11 +1499,11 @@ void deallocData(SbkObject* self, bool cleanup) Py_XDECREF(self->ob_dict); // PYSIDE-571: qApp is no longer allocated. - if (PyObject_IS_GC(reinterpret_cast(self))) + if (PyObject_IS_GC(reinterpret_cast(self))) Py_TYPE(self)->tp_free(self); } -void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_func) +void setTypeUserData(SbkObject *wrapper, void *userData, DeleteUserDataFunc d_func) { SbkObjectTypePrivate *sotp = PepType_SOTP(Py_TYPE(wrapper)); if (sotp->user_data) @@ -1513,7 +1513,7 @@ void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_fu sotp->user_data = userData; } -void* getTypeUserData(SbkObject* wrapper) +void *getTypeUserData(SbkObject *wrapper) { return PepType_SOTP(Py_TYPE(wrapper))->user_data; } @@ -1523,7 +1523,7 @@ static inline bool isNone(const PyObject *o) return o == nullptr || o == Py_None; } -static void removeRefCountKey(SbkObject* self, const char *key) +static void removeRefCountKey(SbkObject *self, const char *key) { if (self->d->referredObjects) { const auto iterPair = self->d->referredObjects->equal_range(key); @@ -1534,7 +1534,7 @@ static void removeRefCountKey(SbkObject* self, const char *key) } } -void keepReference(SbkObject* self, const char* key, PyObject* referredObject, bool append) +void keepReference(SbkObject *self, const char *key, PyObject *referredObject, bool append) { if (isNone(referredObject)) { removeRefCountKey(self, key); @@ -1548,7 +1548,7 @@ void keepReference(SbkObject* self, const char* key, PyObject* referredObject, b return; } - RefCountMap& refCountMap = *(self->d->referredObjects); + RefCountMap &refCountMap = *(self->d->referredObjects); const auto iterPair = refCountMap.equal_range(key); if (std::any_of(iterPair.first, iterPair.second, [referredObject](const RefCountMap::value_type &v) { return v.second == referredObject; })) { @@ -1564,24 +1564,24 @@ void keepReference(SbkObject* self, const char* key, PyObject* referredObject, b Py_INCREF(referredObject); } -void removeReference(SbkObject* self, const char* key, PyObject* referredObject) +void removeReference(SbkObject *self, const char *key, PyObject *referredObject) { if (!isNone(referredObject)) removeRefCountKey(self, key); } -void clearReferences(SbkObject* self) +void clearReferences(SbkObject *self) { if (!self->d->referredObjects) return; - RefCountMap& refCountMap = *(self->d->referredObjects); + RefCountMap &refCountMap = *(self->d->referredObjects); for (auto it = refCountMap.begin(), end = refCountMap.end(); it != end; ++it) Py_DECREF(it->second); self->d->referredObjects->clear(); } -std::string info(SbkObject* self) +std::string info(SbkObject *self) { std::ostringstream s; @@ -1590,7 +1590,7 @@ std::string info(SbkObject* self) if (ObjectType::isUserType(Py_TYPE(self))) bases = getCppBaseClasses(Py_TYPE(self)); else - bases.push_back(reinterpret_cast(Py_TYPE(self))); + bases.push_back(reinterpret_cast(Py_TYPE(self))); s << "C++ address....... "; for (size_t i = 0, size = bases.size(); i < size; ++i) { @@ -1625,7 +1625,7 @@ std::string info(SbkObject* self) } if (self->d->referredObjects && !self->d->referredObjects->empty()) { - Shiboken::RefCountMap& map = *self->d->referredObjects; + Shiboken::RefCountMap &map = *self->d->referredObjects; s << "referred objects.. "; std::string lastKey; for (auto it = map.begin(), end = map.end(); it != end; ++it) { diff --git a/sources/shiboken2/libshiboken/basewrapper.h b/sources/shiboken2/libshiboken/basewrapper.h index 55445b026..7faf223bd 100644 --- a/sources/shiboken2/libshiboken/basewrapper.h +++ b/sources/shiboken2/libshiboken/basewrapper.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of Qt for Python. @@ -57,41 +57,41 @@ struct LIBSHIBOKEN_API SbkObject { PyObject_HEAD /// Instance dictionary. - PyObject* ob_dict; + PyObject *ob_dict; /// List of weak references - PyObject* weakreflist; - SbkObjectPrivate* d; + PyObject *weakreflist; + SbkObjectPrivate *d; }; /// Dealloc the python object \p pyObj and the C++ object represented by it. -LIBSHIBOKEN_API void SbkDeallocWrapper(PyObject* pyObj); -LIBSHIBOKEN_API void SbkDeallocQAppWrapper(PyObject* pyObj); -LIBSHIBOKEN_API void SbkDeallocWrapperWithPrivateDtor(PyObject* self); +LIBSHIBOKEN_API void SbkDeallocWrapper(PyObject *pyObj); +LIBSHIBOKEN_API void SbkDeallocQAppWrapper(PyObject *pyObj); +LIBSHIBOKEN_API void SbkDeallocWrapperWithPrivateDtor(PyObject *self); struct SbkObjectType; /// Function signature for the multiple inheritance information initializers that should be provided by classes with multiple inheritance. -typedef int* (*MultipleInheritanceInitFunction)(const void*); +typedef int *(*MultipleInheritanceInitFunction)(const void *); /** * Special cast function is used to correctly cast an object when it's * part of a multiple inheritance hierarchy. * The implementation of this function is auto generated by the generator and you don't need to care about it. */ -typedef void* (*SpecialCastFunction)(void*, SbkObjectType*); -typedef SbkObjectType* (*TypeDiscoveryFunc)(void*, SbkObjectType*); -typedef void* (*TypeDiscoveryFuncV2)(void*, SbkObjectType*); +typedef void *(*SpecialCastFunction)(void *, SbkObjectType *); +typedef SbkObjectType *(*TypeDiscoveryFunc)(void *, SbkObjectType *); +typedef void *(*TypeDiscoveryFuncV2)(void *, SbkObjectType *); -typedef void* (*ExtendedToCppFunc)(PyObject*); // DEPRECATED. -typedef bool (*ExtendedIsConvertibleFunc)(PyObject*); // DEPRECATED. +typedef void *(*ExtendedToCppFunc)(PyObject *); // DEPRECATED. +typedef bool (*ExtendedIsConvertibleFunc)(PyObject *); // DEPRECATED. // Used in userdata dealloc function -typedef void (*DeleteUserDataFunc)(void*); +typedef void (*DeleteUserDataFunc)(void *); -typedef void (*ObjectDestructor)(void*); +typedef void (*ObjectDestructor)(void *); -typedef void (*SubTypeInitHook)(SbkObjectType*, PyObject*, PyObject*); +typedef void (*SubTypeInitHook)(SbkObjectType *, PyObject *, PyObject *); extern LIBSHIBOKEN_API PyTypeObject *SbkObjectType_TypeF(void); extern LIBSHIBOKEN_API SbkObjectType *SbkObject_TypeF(void); @@ -104,9 +104,9 @@ struct LIBSHIBOKEN_API SbkObjectType PyTypeObject type; }; -LIBSHIBOKEN_API PyObject* SbkObjectTpNew(PyTypeObject* subtype, PyObject*, PyObject*); +LIBSHIBOKEN_API PyObject *SbkObjectTpNew(PyTypeObject *subtype, PyObject *, PyObject *); // the special case of a switchable singleton -LIBSHIBOKEN_API PyObject* SbkQAppTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds); +LIBSHIBOKEN_API PyObject *SbkQAppTpNew(PyTypeObject *subtype, PyObject *args, PyObject *kwds); /** * PYSIDE-832: Use object_dealloc instead of nullptr. @@ -132,36 +132,36 @@ LIBSHIBOKEN_API void init(); /// Delete the class T allocated on \p cptr. template -void callCppDestructor(void* cptr) +void callCppDestructor(void *cptr) { - delete reinterpret_cast(cptr); + delete reinterpret_cast(cptr); } /** * Shiboken::importModule is DEPRECATED. Use Shiboken::Module::import() instead. */ -SBK_DEPRECATED(LIBSHIBOKEN_API bool importModule(const char* moduleName, PyTypeObject*** cppApiPtr)); +SBK_DEPRECATED(LIBSHIBOKEN_API bool importModule(const char *moduleName, PyTypeObject *** cppApiPtr)); // setErrorAboutWrongArguments now gets overload info from the signature module. -LIBSHIBOKEN_API void setErrorAboutWrongArguments(PyObject* args, const char* funcName); +LIBSHIBOKEN_API void setErrorAboutWrongArguments(PyObject *args, const char *funcName); namespace ObjectType { /** * Returns true if the object is an instance of a type created by the Shiboken generator. */ -LIBSHIBOKEN_API bool checkType(PyTypeObject* pyObj); +LIBSHIBOKEN_API bool checkType(PyTypeObject *pyObj); /** * Returns true if this object is an instance of an user defined type derived from an Shiboken type. */ -LIBSHIBOKEN_API bool isUserType(PyTypeObject* pyObj); +LIBSHIBOKEN_API bool isUserType(PyTypeObject *pyObj); /** * Returns true if the constructor of \p ctorType can be called for a instance of type \p myType. * \note This function set a python error when returning false. */ -LIBSHIBOKEN_API bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType); +LIBSHIBOKEN_API bool canCallConstructor(PyTypeObject *myType, PyTypeObject *ctorType); /** * Tells if the \p type represents an object of a class with multiple inheritance in C++. @@ -170,27 +170,27 @@ LIBSHIBOKEN_API bool canCallConstructor(PyTypeObject* myType, PyTypeObjec * \returns true if a call to ObjectType::cast() is needed to obtain the correct * C++ pointer for Python objects of type \p type. */ -LIBSHIBOKEN_API bool hasCast(SbkObjectType* type); +LIBSHIBOKEN_API bool hasCast(SbkObjectType *type); /** * Cast the C++ pointer held by a Python object \p obj of type \p sourceType, * to a C++ pointer of a C++ class indicated by type \p targetType. * \returns The cast C++ pointer. */ -LIBSHIBOKEN_API void* cast(SbkObjectType* sourceType, SbkObject* obj, PyTypeObject* targetType); +LIBSHIBOKEN_API void *cast(SbkObjectType *sourceType, SbkObject *obj, PyTypeObject *targetType); /// Set the C++ cast function for \p type. -LIBSHIBOKEN_API void setCastFunction(SbkObjectType* type, SpecialCastFunction func); +LIBSHIBOKEN_API void setCastFunction(SbkObjectType *type, SpecialCastFunction func); -LIBSHIBOKEN_API void setOriginalName(SbkObjectType* self, const char* name); -LIBSHIBOKEN_API const char* getOriginalName(SbkObjectType* self); +LIBSHIBOKEN_API void setOriginalName(SbkObjectType *self, const char *name); +LIBSHIBOKEN_API const char *getOriginalName(SbkObjectType *self); -LIBSHIBOKEN_API void setTypeDiscoveryFunctionV2(SbkObjectType* self, TypeDiscoveryFuncV2 func); -LIBSHIBOKEN_API void copyMultipleInheritance(SbkObjectType *self, SbkObjectType *other); -LIBSHIBOKEN_API void setMultipleInheritanceFunction(SbkObjectType* self, MultipleInheritanceInitFunction func); +LIBSHIBOKEN_API void setTypeDiscoveryFunctionV2(SbkObjectType *self, TypeDiscoveryFuncV2 func); +LIBSHIBOKEN_API void copyMultipleInheritance(SbkObjectType *self, SbkObjectType *other); +LIBSHIBOKEN_API void setMultipleInheritanceFunction(SbkObjectType *self, MultipleInheritanceInitFunction func); LIBSHIBOKEN_API MultipleInheritanceInitFunction getMultipleInheritanceFunction(SbkObjectType *self); -LIBSHIBOKEN_API void setDestructorFunction(SbkObjectType* self, ObjectDestructor func); +LIBSHIBOKEN_API void setDestructorFunction(SbkObjectType *self, ObjectDestructor func); -LIBSHIBOKEN_API void initPrivateData(SbkObjectType* self); +LIBSHIBOKEN_API void initPrivateData(SbkObjectType *self); enum WrapperFlags { @@ -232,13 +232,13 @@ LIBSHIBOKEN_API SbkObjectType *introduceWrapperType(PyObject *enclosingObject, * The hook gets 3 params, they are: The new type being created, args and kwds. The last two are the very * same got from tp_new. */ -LIBSHIBOKEN_API void setSubTypeInitHook(SbkObjectType* self, SubTypeInitHook func); +LIBSHIBOKEN_API void setSubTypeInitHook(SbkObjectType *self, SubTypeInitHook func); /** * Get the user data previously set by Shiboken::Object::setTypeUserData */ -LIBSHIBOKEN_API void* getTypeUserData(SbkObjectType* self); -LIBSHIBOKEN_API void setTypeUserData(SbkObjectType* self, void* userData, DeleteUserDataFunc d_func); +LIBSHIBOKEN_API void *getTypeUserData(SbkObjectType *self); +LIBSHIBOKEN_API void setTypeUserData(SbkObjectType *self, void *userData, DeleteUserDataFunc d_func); /** * Return an instance of SbkObjectType for a C++ type name as determined by @@ -261,23 +261,23 @@ namespace Object { /** * Returns a string with information about the internal state of the instance object, useful for debug purposes. */ -LIBSHIBOKEN_API std::string info(SbkObject* self); +LIBSHIBOKEN_API std::string info(SbkObject *self); /** * Returns true if the object is an instance of a type created by the Shiboken generator. */ -LIBSHIBOKEN_API bool checkType(PyObject* pyObj); +LIBSHIBOKEN_API bool checkType(PyObject *pyObj); /** * Returns true if this object type is an instance of an user defined type derived from an Shiboken type. * \see Shiboken::ObjectType::isUserType */ -LIBSHIBOKEN_API bool isUserType(PyObject* pyObj); +LIBSHIBOKEN_API bool isUserType(PyObject *pyObj); /** * Generic function used to make ObjectType hashable, the C++ pointer is used as hash value. */ -LIBSHIBOKEN_API Py_hash_t hash(PyObject* pyObj); +LIBSHIBOKEN_API Py_hash_t hash(PyObject *pyObj); /** * Find a child of given wrapper having same address having the specified type. @@ -294,101 +294,101 @@ LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper, * and as fallback. * \param typeName If non-null, this will be used as helper to find the correct Python type for this object. */ -LIBSHIBOKEN_API PyObject* newObject(SbkObjectType* instanceType, - void* cptr, - bool hasOwnership = true, - bool isExactType = false, - const char* typeName = 0); +LIBSHIBOKEN_API PyObject *newObject(SbkObjectType *instanceType, + void *cptr, + bool hasOwnership = true, + bool isExactType = false, + const char *typeName = nullptr); /** * Changes the valid flag of a PyObject, invalid objects will raise an exception when someone tries to access it. */ -LIBSHIBOKEN_API void setValidCpp(SbkObject* pyObj, bool value); +LIBSHIBOKEN_API void setValidCpp(SbkObject *pyObj, bool value); /** * Tells shiboken the Python object \p pyObj has a C++ wrapper used to intercept virtual method calls. */ -LIBSHIBOKEN_API void setHasCppWrapper(SbkObject* pyObj, bool value); +LIBSHIBOKEN_API void setHasCppWrapper(SbkObject *pyObj, bool value); /** * Return true if the Python object \p pyObj has a C++ wrapper used to intercept virtual method calls. */ -LIBSHIBOKEN_API bool hasCppWrapper(SbkObject* pyObj); +LIBSHIBOKEN_API bool hasCppWrapper(SbkObject *pyObj); /** * Return true if the Python object was created by Python, false otherwise. * \note This function was added to libshiboken only to be used by shiboken.wasCreatedByPython() */ -LIBSHIBOKEN_API bool wasCreatedByPython(SbkObject* pyObj); +LIBSHIBOKEN_API bool wasCreatedByPython(SbkObject *pyObj); /** * Call the C++ object destructor and invalidates the Python object. * \note This function was added to libshiboken only to be used by shiboken.delete() */ -LIBSHIBOKEN_API void callCppDestructors(SbkObject* pyObj); +LIBSHIBOKEN_API void callCppDestructors(SbkObject *pyObj); /** * Return true if the Python is responsible for deleting the underlying C++ object. */ -LIBSHIBOKEN_API bool hasOwnership(SbkObject* pyObj); +LIBSHIBOKEN_API bool hasOwnership(SbkObject *pyObj); /** * Sets python as responsible to delete the underlying C++ object. * \note You this overload only when the PyObject can be a sequence and you want to * call this function for every item in the sequence. - * \see getOwnership(SbkObject*) + * \see getOwnership(SbkObject *) */ -LIBSHIBOKEN_API void getOwnership(PyObject* pyObj); +LIBSHIBOKEN_API void getOwnership(PyObject *pyObj); /** * Sets python as responsible to delete the underlying C++ object. */ -LIBSHIBOKEN_API void getOwnership(SbkObject* pyObj); +LIBSHIBOKEN_API void getOwnership(SbkObject *pyObj); /** * Release the ownership, so Python will not delete the underlying C++ object. * \note You this overload only when the PyObject can be a sequence and you want to * call this function for every item in the sequence. - * \see releaseOwnership(SbkObject*) + * \see releaseOwnership(SbkObject *) */ -LIBSHIBOKEN_API void releaseOwnership(PyObject* pyObj); +LIBSHIBOKEN_API void releaseOwnership(PyObject *pyObj); /** * Release the ownership, so Python will not delete the underlying C++ object. */ -LIBSHIBOKEN_API void releaseOwnership(SbkObject* pyObj); +LIBSHIBOKEN_API void releaseOwnership(SbkObject *pyObj); /** * Get the C++ pointer of type \p desiredType from a Python object. */ -LIBSHIBOKEN_API void* cppPointer(SbkObject* pyObj, PyTypeObject* desiredType); +LIBSHIBOKEN_API void *cppPointer(SbkObject *pyObj, PyTypeObject *desiredType); /** * Return a list with all C++ pointers held from a Python object. * \note This function was added to libshiboken only to be used by shiboken.getCppPointer() */ -LIBSHIBOKEN_API std::vector cppPointers(SbkObject* pyObj); +LIBSHIBOKEN_API std::vectorcppPointers(SbkObject *pyObj); /** * Set the C++ pointer of type \p desiredType of a Python object. */ -LIBSHIBOKEN_API bool setCppPointer(SbkObject* sbkObj, PyTypeObject* desiredType, void* cptr); +LIBSHIBOKEN_API bool setCppPointer(SbkObject *sbkObj, PyTypeObject *desiredType, void *cptr); /** * Returns false and sets a Python RuntimeError if the Python wrapper is not marked as valid. */ -LIBSHIBOKEN_API bool isValid(PyObject* pyObj); +LIBSHIBOKEN_API bool isValid(PyObject *pyObj); /** * Returns false if the Python wrapper is not marked as valid. * \param pyObj the object. * \param throwPyError sets a Python RuntimeError when the object isn't valid. */ -LIBSHIBOKEN_API bool isValid(SbkObject* pyObj, bool throwPyError = true); +LIBSHIBOKEN_API bool isValid(SbkObject *pyObj, bool throwPyError = true); /** * Returns false if the Python wrapper is not marked as valid. * \param pyObj the object. * \param throwPyError sets a Python RuntimeError when the object isn't valid. */ -LIBSHIBOKEN_API bool isValid(PyObject* pyObj, bool throwPyError); +LIBSHIBOKEN_API bool isValid(PyObject *pyObj, bool throwPyError); /** * Set the parent of \p child to \p parent. @@ -396,36 +396,36 @@ LIBSHIBOKEN_API bool isValid(PyObject* pyObj, bool throwPyError); * \param parent the parent object, if null, the child will have no parents. * \param child the child. */ -LIBSHIBOKEN_API void setParent(PyObject* parent, PyObject* child); +LIBSHIBOKEN_API void setParent(PyObject *parent, PyObject *child); /** * Remove this child from their parent, if any. * \param child the child. */ -LIBSHIBOKEN_API void removeParent(SbkObject* child, bool giveOwnershipBack = true, bool keepReferenc = false); +LIBSHIBOKEN_API void removeParent(SbkObject *child, bool giveOwnershipBack = true, bool keepReferenc = false); /** * Mark the object as invalid */ -LIBSHIBOKEN_API void invalidate(SbkObject* self); +LIBSHIBOKEN_API void invalidate(SbkObject *self); /** * Help function can be used to invalidate a sequence of object **/ -LIBSHIBOKEN_API void invalidate(PyObject* pyobj); +LIBSHIBOKEN_API void invalidate(PyObject *pyobj); /** * Make the object valid again */ -LIBSHIBOKEN_API void makeValid(SbkObject* self); +LIBSHIBOKEN_API void makeValid(SbkObject *self); -/// \deprecated Use destroy(SbkObject*, void*) -SBK_DEPRECATED(LIBSHIBOKEN_API void destroy(SbkObject* self)); +/// \deprecated Use destroy(SbkObject *, void *) +SBK_DEPRECATED(LIBSHIBOKEN_API void destroy(SbkObject *self)); /** * Destroy any data in Shiboken structure and c++ pointer if the pyboject has the ownership */ -LIBSHIBOKEN_API void destroy(SbkObject* self, void* cppData); +LIBSHIBOKEN_API void destroy(SbkObject *self, void *cppData); /** * Set user data on type of \p wrapper. @@ -433,11 +433,11 @@ LIBSHIBOKEN_API void destroy(SbkObject* self, void* cppData); * \param userData the user data * \param d_func a function used to delete the user data */ -LIBSHIBOKEN_API void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_func); +LIBSHIBOKEN_API void setTypeUserData(SbkObject *wrapper, void *userData, DeleteUserDataFunc d_func); /** * Get the user data previously set by Shiboken::Object::setTypeUserData */ -LIBSHIBOKEN_API void* getTypeUserData(SbkObject* wrapper); +LIBSHIBOKEN_API void *getTypeUserData(SbkObject *wrapper); /** * Increments the reference count of the referred Python object. @@ -451,7 +451,7 @@ LIBSHIBOKEN_API void* getTypeUserData(SbkObject* wrapper); * \param key a key that identifies the C++ method signature and argument where the referred Object came from. * \param referredObject the object whose reference is used by the self object. */ -LIBSHIBOKEN_API void keepReference(SbkObject* self, const char* key, PyObject* referredObject, bool append = false); +LIBSHIBOKEN_API void keepReference(SbkObject *self, const char *key, PyObject *referredObject, bool append = false); /** * Removes any reference previously added by keepReference function @@ -459,7 +459,7 @@ LIBSHIBOKEN_API void keepReference(SbkObject* self, const char* key, PyOb * \param key a key that identifies the C++ method signature and argument from where the referred Object came. * \param referredObject the object whose reference is used by the self object. */ -LIBSHIBOKEN_API void removeReference(SbkObject* self, const char* key, PyObject* referredObject); +LIBSHIBOKEN_API void removeReference(SbkObject *self, const char *key, PyObject *referredObject); } // namespace Object diff --git a/sources/shiboken2/libshiboken/basewrapper_p.h b/sources/shiboken2/libshiboken/basewrapper_p.h index f8a381078..feba6561e 100644 --- a/sources/shiboken2/libshiboken/basewrapper_p.h +++ b/sources/shiboken2/libshiboken/basewrapper_p.h @@ -61,7 +61,7 @@ namespace Shiboken typedef std::unordered_multimap RefCountMap; /// Linked list of SbkBaseWrapper pointers -typedef std::set ChildrenList; +using ChildrenList = std::set; /// Structure used to store information about object parent and children. struct ParentInfo @@ -69,7 +69,7 @@ struct ParentInfo /// Default ctor. ParentInfo() : parent(0), hasWrapperRef(false) {} /// Pointer to parent object. - SbkObject* parent; + SbkObject *parent; /// List of object children. ChildrenList children; /// has internal ref @@ -88,7 +88,7 @@ extern "C" struct SbkObjectPrivate { /// Pointer to the C++ class. - void** cptr; + void ** cptr; /// True when Python is responsible for freeing the used memory. unsigned int hasOwnership : 1; /// This is true when the C++ class of the wrapped object has a virtual destructor AND was created by Python. @@ -98,9 +98,9 @@ struct SbkObjectPrivate /// Marked as true when the object constructor was called unsigned int cppObjectCreated : 1; /// Information about the object parents and children, may be null. - Shiboken::ParentInfo* parentInfo; + Shiboken::ParentInfo *parentInfo; /// Manage reference count of objects that are referred to but not owned from. - Shiboken::RefCountMap* referredObjects; + Shiboken::RefCountMap *referredObjects; ~SbkObjectPrivate() { @@ -121,8 +121,8 @@ struct SbkObjectPrivate struct SbkObjectTypePrivate { - SbkConverter* converter; - int* mi_offsets; + SbkConverter *converter; + int *mi_offsets; MultipleInheritanceInitFunction mi_init; /// Special cast function, null if this class doesn't have multiple inheritance. @@ -134,16 +134,16 @@ struct SbkObjectTypePrivate int is_multicpp : 1; /// True if this type was defined by the user. int is_user_type : 1; - /// Tells is the type is a value type or an object-type, see BEHAVIOUR_* constants. + /// Tells is the type is a value type or an object-type, see BEHAVIOUR_ *constants. // TODO-CONVERTERS: to be deprecated/removed int type_behaviour : 2; int delete_in_main_thread : 1; /// C++ name - char* original_name; + char *original_name; /// Type user data - void* user_data; + void *user_data; DeleteUserDataFunc d_func; - void (*subtype_init)(SbkObjectType*, PyObject*, PyObject*); + void (*subtype_init)(SbkObjectType *, PyObject *, PyObject *); }; @@ -165,7 +165,7 @@ struct DestructorEntry /** * Utility function used to transform a PyObject that implements sequence protocol into a std::list. **/ -std::vector splitPyObject(PyObject* pyObj); +std::vector splitPyObject(PyObject *pyObj); /** * Visitor class used by walkOnClassHierarchy function. @@ -211,7 +211,7 @@ private: class GetIndexVisitor : public HierarchyVisitor { public: - explicit GetIndexVisitor(PyTypeObject* desiredType) : m_desiredType(desiredType) {} + explicit GetIndexVisitor(PyTypeObject *desiredType) : m_desiredType(desiredType) {} bool visit(SbkObjectType *node) override; @@ -248,21 +248,21 @@ private: */ bool walkThroughClassHierarchy(PyTypeObject *currentType, HierarchyVisitor *visitor); -inline int getTypeIndexOnHierarchy(PyTypeObject* baseType, PyTypeObject* desiredType) +inline int getTypeIndexOnHierarchy(PyTypeObject *baseType, PyTypeObject *desiredType) { GetIndexVisitor visitor(desiredType); walkThroughClassHierarchy(baseType, &visitor); return visitor.index(); } -inline int getNumberOfCppBaseClasses(PyTypeObject* baseType) +inline int getNumberOfCppBaseClasses(PyTypeObject *baseType) { BaseCountVisitor visitor; walkThroughClassHierarchy(baseType, &visitor); return visitor.count(); } -inline std::vector getCppBaseClasses(PyTypeObject* baseType) +inline std::vector getCppBaseClasses(PyTypeObject *baseType) { BaseAccumulatorVisitor visitor; walkThroughClassHierarchy(baseType, &visitor); @@ -275,12 +275,12 @@ namespace Object * Decrements the reference counters of every object referred by self. * \param self the wrapper instance that keeps references to other objects. */ -void clearReferences(SbkObject* self); +void clearReferences(SbkObject *self); /** * Destroy internal data **/ -void deallocData(SbkObject* self, bool doCleanup); +void deallocData(SbkObject *self, bool doCleanup); } // namespace Object diff --git a/sources/shiboken2/libshiboken/bindingmanager.cpp b/sources/shiboken2/libshiboken/bindingmanager.cpp index 8a9e912fd..c526d9b2e 100644 --- a/sources/shiboken2/libshiboken/bindingmanager.cpp +++ b/sources/shiboken2/libshiboken/bindingmanager.cpp @@ -64,7 +64,7 @@ public: Graph() = default; - void addEdge(SbkObjectType* from, SbkObjectType* to) + void addEdge(SbkObjectType *from, SbkObjectType *to) { m_edges[from].push_back(to); } @@ -78,7 +78,7 @@ public: for (auto i = m_edges.begin(), end = m_edges.end(); i != end; ++i) { auto node1 = reinterpret_cast(i->first); - const NodeList& nodeList = i->second; + const NodeList &nodeList = i->second; for (const SbkObjectType *o : nodeList) { auto node2 = reinterpret_cast(o); file << '"' << node2->tp_name << "\" -> \"" @@ -89,13 +89,13 @@ public: } #endif - SbkObjectType* identifyType(void** cptr, SbkObjectType* type, SbkObjectType* baseType) const + SbkObjectType *identifyType(void **cptr, SbkObjectType *type, SbkObjectType *baseType) const { Edges::const_iterator edgesIt = m_edges.find(type); if (edgesIt != m_edges.end()) { - const NodeList& adjNodes = m_edges.find(type)->second; + const NodeList &adjNodes = m_edges.find(type)->second; for (SbkObjectType *node : adjNodes) { - SbkObjectType* newType = identifyType(cptr, node, baseType); + SbkObjectType *newType = identifyType(cptr, node, baseType); if (newType) return newType; } @@ -106,7 +106,7 @@ public: } if (typeFound) { // This "typeFound != type" is needed for backwards compatibility with old modules using a newer version of - // libshiboken because old versions of type_discovery function used to return a SbkObjectType* instead of + // libshiboken because old versions of type_discovery function used to return a SbkObjectType *instead of // a possible variation of the C++ instance pointer (*cptr). if (typeFound != type) *cptr = typeFound; @@ -118,7 +118,7 @@ public: #ifndef NDEBUG -static void showWrapperMap(const WrapperMap& wrapperMap) +static void showWrapperMap(const WrapperMap &wrapperMap) { if (Py_VerboseFlag > 0) { fprintf(stderr, "-------------------------------\n"); @@ -144,12 +144,12 @@ struct BindingManager::BindingManagerPrivate { bool destroying; BindingManagerPrivate() : destroying(false) {} - bool releaseWrapper(void* cptr, SbkObject* wrapper); - void assignWrapper(SbkObject* wrapper, const void* cptr); + bool releaseWrapper(void *cptr, SbkObject *wrapper); + void assignWrapper(SbkObject *wrapper, const void *cptr); }; -bool BindingManager::BindingManagerPrivate::releaseWrapper(void* cptr, SbkObject* wrapper) +bool BindingManager::BindingManagerPrivate::releaseWrapper(void *cptr, SbkObject *wrapper) { // The wrapper argument is checked to ensure that the correct wrapper is released. // Returns true if the correct wrapper is found and released. @@ -162,7 +162,7 @@ bool BindingManager::BindingManagerPrivate::releaseWrapper(void* cptr, SbkObject return false; } -void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject* wrapper, const void* cptr) +void BindingManager::BindingManagerPrivate::assignWrapper(SbkObject *wrapper, const void *cptr) { assert(cptr); WrapperMap::iterator iter = wrapperMapper.find(cptr); @@ -192,27 +192,27 @@ BindingManager::~BindingManager() * shutting down. */ if (Py_IsInitialized()) { // ensure the interpreter is still valid while (!m_d->wrapperMapper.empty()) { - Object::destroy(m_d->wrapperMapper.begin()->second, const_cast(m_d->wrapperMapper.begin()->first)); + Object::destroy(m_d->wrapperMapper.begin()->second, const_cast(m_d->wrapperMapper.begin()->first)); } assert(m_d->wrapperMapper.empty()); } delete m_d; } -BindingManager& BindingManager::instance() { +BindingManager &BindingManager::instance() { static BindingManager singleton; return singleton; } -bool BindingManager::hasWrapper(const void* cptr) +bool BindingManager::hasWrapper(const void *cptr) { return m_d->wrapperMapper.find(cptr) != m_d->wrapperMapper.end(); } -void BindingManager::registerWrapper(SbkObject* pyObj, void* cptr) +void BindingManager::registerWrapper(SbkObject *pyObj, void *cptr) { - SbkObjectType* instanceType = reinterpret_cast(Py_TYPE(pyObj)); - SbkObjectTypePrivate* d = PepType_SOTP(instanceType); + auto instanceType = reinterpret_cast(Py_TYPE(pyObj)); + SbkObjectTypePrivate *d = PepType_SOTP(instanceType); if (!d) return; @@ -221,27 +221,27 @@ void BindingManager::registerWrapper(SbkObject* pyObj, void* cptr) d->mi_offsets = d->mi_init(cptr); m_d->assignWrapper(pyObj, cptr); if (d->mi_offsets) { - int* offset = d->mi_offsets; + int *offset = d->mi_offsets; while (*offset != -1) { if (*offset > 0) - m_d->assignWrapper(pyObj, reinterpret_cast((std::size_t) cptr + (*offset))); + m_d->assignWrapper(pyObj, reinterpret_cast((std::size_t) cptr + (*offset))); offset++; } } } -void BindingManager::releaseWrapper(SbkObject* sbkObj) +void BindingManager::releaseWrapper(SbkObject *sbkObj) { - SbkObjectType* sbkType = reinterpret_cast(Py_TYPE(sbkObj)); - SbkObjectTypePrivate* d = PepType_SOTP(sbkType); + auto sbkType = reinterpret_cast(Py_TYPE(sbkObj)); + SbkObjectTypePrivate *d = PepType_SOTP(sbkType); int numBases = ((d && d->is_multicpp) ? getNumberOfCppBaseClasses(Py_TYPE(sbkObj)) : 1); - void** cptrs = reinterpret_cast(sbkObj)->d->cptr; + void ** cptrs = reinterpret_cast(sbkObj)->d->cptr; for (int i = 0; i < numBases; ++i) { unsigned char *cptr = reinterpret_cast(cptrs[i]); m_d->releaseWrapper(cptr, sbkObj); if (d && d->mi_offsets) { - int* offset = d->mi_offsets; + int *offset = d->mi_offsets; while (*offset != -1) { if (*offset > 0) m_d->releaseWrapper(reinterpret_cast((std::size_t) cptr + (*offset)), sbkObj); @@ -264,7 +264,7 @@ void BindingManager::addToDeletionInMainThread(const DestructorEntry &e) m_d->deleteInMainThread.push_back(e); } -SbkObject* BindingManager::retrieveWrapper(const void* cptr) +SbkObject *BindingManager::retrieveWrapper(const void *cptr) { WrapperMap::iterator iter = m_d->wrapperMapper.find(cptr); if (iter == m_d->wrapperMapper.end()) @@ -272,34 +272,34 @@ SbkObject* BindingManager::retrieveWrapper(const void* cptr) return iter->second; } -PyObject* BindingManager::getOverride(const void* cptr, const char* methodName) +PyObject *BindingManager::getOverride(const void *cptr, const char *methodName) { - SbkObject* wrapper = retrieveWrapper(cptr); + SbkObject *wrapper = retrieveWrapper(cptr); // The refcount can be 0 if the object is dieing and someone called // a virtual method from the destructor if (!wrapper || reinterpret_cast(wrapper)->ob_refcnt == 0) return 0; if (wrapper->ob_dict) { - PyObject* method = PyDict_GetItemString(wrapper->ob_dict, methodName); + PyObject *method = PyDict_GetItemString(wrapper->ob_dict, methodName); if (method) { Py_INCREF(reinterpret_cast(method)); return method; } } - PyObject* pyMethodName = Shiboken::String::fromCString(methodName); + PyObject *pyMethodName = Shiboken::String::fromCString(methodName); PyObject *method = PyObject_GetAttr(reinterpret_cast(wrapper), pyMethodName); if (method && PyMethod_Check(method) - && PyMethod_GET_SELF(method) == reinterpret_cast(wrapper)) { - PyObject* defaultMethod; - PyObject* mro = Py_TYPE(wrapper)->tp_mro; + && PyMethod_GET_SELF(method) == reinterpret_cast(wrapper)) { + PyObject *defaultMethod; + PyObject *mro = Py_TYPE(wrapper)->tp_mro; // The first class in the mro (index 0) is the class being checked and it should not be tested. // The last class in the mro (size - 1) is the base Python object class which should not be tested also. for (int i = 1; i < PyTuple_GET_SIZE(mro) - 1; i++) { - PyTypeObject* parent = reinterpret_cast(PyTuple_GET_ITEM(mro, i)); + PyTypeObject *parent = reinterpret_cast(PyTuple_GET_ITEM(mro, i)); if (parent->tp_dict) { defaultMethod = PyDict_GetItem(parent->tp_dict, pyMethodName); if (defaultMethod && PyMethod_GET_FUNCTION(method) != defaultMethod) { @@ -315,34 +315,34 @@ PyObject* BindingManager::getOverride(const void* cptr, const char* methodName) return 0; } -void BindingManager::addClassInheritance(SbkObjectType* parent, SbkObjectType* child) +void BindingManager::addClassInheritance(SbkObjectType *parent, SbkObjectType *child) { m_d->classHierarchy.addEdge(parent, child); } -SbkObjectType* BindingManager::resolveType(void* cptr, SbkObjectType* type) +SbkObjectType *BindingManager::resolveType(void *cptr, SbkObjectType *type) { return resolveType(&cptr, type); } -SbkObjectType* BindingManager::resolveType(void** cptr, SbkObjectType* type) +SbkObjectType *BindingManager::resolveType(void **cptr, SbkObjectType *type) { - SbkObjectType* identifiedType = m_d->classHierarchy.identifyType(cptr, type, type); + SbkObjectType *identifiedType = m_d->classHierarchy.identifyType(cptr, type, type); return identifiedType ? identifiedType : type; } -std::set BindingManager::getAllPyObjects() +std::set BindingManager::getAllPyObjects() { - std::set pyObjects; - const WrapperMap& wrappersMap = m_d->wrapperMapper; + std::set pyObjects; + const WrapperMap &wrappersMap = m_d->wrapperMapper; WrapperMap::const_iterator it = wrappersMap.begin(); for (; it != wrappersMap.end(); ++it) - pyObjects.insert(reinterpret_cast(it->second)); + pyObjects.insert(reinterpret_cast(it->second)); return pyObjects; } -void BindingManager::visitAllPyObjects(ObjectVisitor visitor, void* data) +void BindingManager::visitAllPyObjects(ObjectVisitor visitor, void *data) { WrapperMap copy = m_d->wrapperMapper; for (WrapperMap::iterator it = copy.begin(); it != copy.end(); ++it) { diff --git a/sources/shiboken2/libshiboken/bindingmanager.h b/sources/shiboken2/libshiboken/bindingmanager.h index d03aa999a..bfcbdc79b 100644 --- a/sources/shiboken2/libshiboken/bindingmanager.h +++ b/sources/shiboken2/libshiboken/bindingmanager.h @@ -52,36 +52,36 @@ namespace Shiboken struct DestructorEntry; -typedef void (*ObjectVisitor)(SbkObject*, void*); +typedef void (*ObjectVisitor)(SbkObject *, void *); class LIBSHIBOKEN_API BindingManager { public: - BindingManager(const BindingManager&) = delete; - BindingManager(BindingManager&&) = delete; - BindingManager& operator=(const BindingManager&) = delete; - BindingManager& operator=(BindingManager&&) = delete; + BindingManager(const BindingManager &) = delete; + BindingManager(BindingManager &&) = delete; + BindingManager &operator=(const BindingManager &) = delete; + BindingManager &operator=(BindingManager &&) = delete; - static BindingManager& instance(); + static BindingManager &instance(); bool hasWrapper(const void *cptr); - void registerWrapper(SbkObject* pyObj, void* cptr); - void releaseWrapper(SbkObject* wrapper); + void registerWrapper(SbkObject *pyObj, void *cptr); + void releaseWrapper(SbkObject *wrapper); void runDeletionInMainThread(); void addToDeletionInMainThread(const DestructorEntry &); - SbkObject* retrieveWrapper(const void* cptr); - PyObject* getOverride(const void* cptr, const char* methodName); + SbkObject *retrieveWrapper(const void *cptr); + PyObject *getOverride(const void *cptr, const char *methodName); - void addClassInheritance(SbkObjectType* parent, SbkObjectType* child); + void addClassInheritance(SbkObjectType *parent, SbkObjectType *child); /** - * \deprecated Use \fn resolveType(void**, SbkObjectType*), this version is broken when used with multiple inheritance + * \deprecated Use \fn resolveType(void **, SbkObjectType *), this version is broken when used with multiple inheritance * because the \p cptr pointer of the discovered type may be different of the given \p cptr in case * of multiple inheritance */ - SBK_DEPRECATED(SbkObjectType* resolveType(void* cptr, SbkObjectType* type)); + SBK_DEPRECATED(SbkObjectType *resolveType(void *cptr, SbkObjectType *type)); /** * Try to find the correct type of *cptr knowing that it's at least of type \p type. * In case of multiple inheritance this function may change the contents of cptr. @@ -89,9 +89,9 @@ public: * \param type type of *cptr * \warning This function is slow, use it only as last resort. */ - SbkObjectType* resolveType(void** cptr, SbkObjectType* type); + SbkObjectType *resolveType(void **cptr, SbkObjectType *type); - std::set getAllPyObjects(); + std::set getAllPyObjects(); /** * Calls the function \p visitor for each object registered on binding manager. @@ -100,14 +100,14 @@ public: * \param visitor function called for each object. * \param data user data passed as second argument to the visitor function. */ - void visitAllPyObjects(ObjectVisitor visitor, void* data); + void visitAllPyObjects(ObjectVisitor visitor, void *data); private: ~BindingManager(); BindingManager(); struct BindingManagerPrivate; - BindingManagerPrivate* m_d; + BindingManagerPrivate *m_d; }; } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/bufferprocs_py37.cpp b/sources/shiboken2/libshiboken/bufferprocs_py37.cpp index 84d670d21..ddb07390e 100644 --- a/sources/shiboken2/libshiboken/bufferprocs_py37.cpp +++ b/sources/shiboken2/libshiboken/bufferprocs_py37.cpp @@ -147,19 +147,18 @@ PyBuffer_IsContiguous(const Pep_buffer *view, char order) } -void* +void * PyBuffer_GetPointer(Pep_buffer *view, Py_ssize_t *indices) { - char* pointer; int i; - pointer = (char *)view->buf; + auto pointer = reinterpret_cast(view->buf); for (i = 0; i < view->ndim; i++) { pointer += view->strides[i]*indices[i]; if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) { - pointer = *((char**)pointer) + view->suboffsets[i]; + pointer = *reinterpret_cast(pointer) + view->suboffsets[i]; } } - return (void*)pointer; + return pointer; } @@ -221,7 +220,7 @@ PyBuffer_FromContiguous(Pep_buffer *view, void *buf, Py_ssize_t len, char fort) PyErr_NoMemory(); return -1; } - for (k=0; kndim;k++) { + for (k=0; kndim; k++) { indices[k] = 0; } diff --git a/sources/shiboken2/libshiboken/debugfreehook.cpp b/sources/shiboken2/libshiboken/debugfreehook.cpp index c66866cf1..3d52d88dc 100644 --- a/sources/shiboken2/libshiboken/debugfreehook.cpp +++ b/sources/shiboken2/libshiboken/debugfreehook.cpp @@ -107,8 +107,8 @@ static int DebugAllocHook(int nAllocType, void *pvData, #endif // _WIN32 && _DEBUG #ifdef __GLIBC__ -static void (*lastFreeHook)(void* ptr, const void* caller); -static void DebugFreeHook(void* ptr, const void* caller) +static void (*lastFreeHook)(void *ptr, const void *caller); +static void DebugFreeHook(void *ptr, const void *caller) { testPointerBeingFreed(ptr); @@ -150,7 +150,7 @@ void debugInstallFreeHook(void) #endif #ifdef __APPLE__ - malloc_zone_t* zone = malloc_default_zone(); + malloc_zone_t *zone = malloc_default_zone(); assert(zone != NULL); //remove the write protection from the zone struct if (zone->version >= 8) { @@ -176,7 +176,7 @@ void debugRemoveFreeHook(void) #endif #ifdef __APPLE__ - malloc_zone_t* zone = malloc_default_zone(); + malloc_zone_t *zone = malloc_default_zone(); assert(zone != NULL); //remove the write protection from the zone struct if (zone->version >= 8) { diff --git a/sources/shiboken2/libshiboken/gilstate.h b/sources/shiboken2/libshiboken/gilstate.h index 9da4871d1..f0ff45d59 100644 --- a/sources/shiboken2/libshiboken/gilstate.h +++ b/sources/shiboken2/libshiboken/gilstate.h @@ -49,10 +49,10 @@ namespace Shiboken class LIBSHIBOKEN_API GilState { public: - GilState(const GilState&) = delete; - GilState(GilState&&) = delete; - GilState& operator=(const GilState&) = delete; - GilState& operator=(GilState&&) = delete; + GilState(const GilState &) = delete; + GilState(GilState &&) = delete; + GilState &operator=(const GilState &) = delete; + GilState &operator=(GilState &&) = delete; GilState(); ~GilState(); diff --git a/sources/shiboken2/libshiboken/helper.cpp b/sources/shiboken2/libshiboken/helper.cpp index e42daff07..1a2dc7ab9 100644 --- a/sources/shiboken2/libshiboken/helper.cpp +++ b/sources/shiboken2/libshiboken/helper.cpp @@ -51,7 +51,7 @@ namespace Shiboken { // PySide-510: Changed from PySequence to PyList, which is correct. -bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defaultAppName) +bool listToArgcArgv(PyObject *argList, int *argc, char ***argv, const char *defaultAppName) { if (!PyList_Check(argList)) return false; @@ -63,7 +63,7 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa Shiboken::AutoDecRef args(PySequence_Fast(argList, 0)); int numArgs = int(PySequence_Fast_GET_SIZE(argList)); for (int i = 0; i < numArgs; ++i) { - PyObject* item = PyList_GET_ITEM(args.object(), i); + PyObject *item = PyList_GET_ITEM(args.object(), i); if (!PyBytes_Check(item) && !PyUnicode_Check(item)) return false; } @@ -73,17 +73,17 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa numArgs = 1; *argc = numArgs; - *argv = new char*[*argc]; + *argv = new char *[*argc]; if (hasEmptyArgList) { // Try to get the script name - PyObject* globals = PyEval_GetGlobals(); - PyObject* appName = PyDict_GetItemString(globals, "__file__"); + PyObject *globals = PyEval_GetGlobals(); + PyObject *appName = PyDict_GetItemString(globals, "__file__"); (*argv)[0] = strdup(appName ? Shiboken::String::toCString(appName) : defaultAppName); } else { for (int i = 0; i < numArgs; ++i) { - PyObject* item = PyList_GET_ITEM(args.object(), i); - char* string = 0; + PyObject *item = PyList_GET_ITEM(args.object(), i); + char *string = 0; if (Shiboken::String::check(item)) { string = strdup(Shiboken::String::toCString(item)); } @@ -94,17 +94,17 @@ bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defa return true; } -int* sequenceToIntArray(PyObject* obj, bool zeroTerminated) +int *sequenceToIntArray(PyObject *obj, bool zeroTerminated) { AutoDecRef seq(PySequence_Fast(obj, "Sequence of ints expected")); if (seq.isNull()) return 0; Py_ssize_t size = PySequence_Fast_GET_SIZE(seq.object()); - int* array = new int[size + (zeroTerminated ? 1 : 0)]; + int *array = new int[size + (zeroTerminated ? 1 : 0)]; for (int i = 0; i < size; i++) { - PyObject* item = PySequence_Fast_GET_ITEM(seq.object(), i); + PyObject *item = PySequence_Fast_GET_ITEM(seq.object(), i); if (!PyInt_Check(item)) { PyErr_SetString(PyExc_TypeError, "Sequence of ints expected"); delete[] array; @@ -121,7 +121,7 @@ int* sequenceToIntArray(PyObject* obj, bool zeroTerminated) } -int warning(PyObject* category, int stacklevel, const char* format, ...) +int warning(PyObject *category, int stacklevel, const char *format, ...) { va_list args; va_start(args, format); @@ -134,7 +134,7 @@ int warning(PyObject* category, int stacklevel, const char* format, ...) // check the necessary memory int size = vsnprintf(NULL, 0, format, args) + 1; - char* message = new char[size]; + auto message = new char[size]; int result = 0; if (message) { // format the message diff --git a/sources/shiboken2/libshiboken/helper.h b/sources/shiboken2/libshiboken/helper.h index 9b6d8903f..6c29ad728 100644 --- a/sources/shiboken2/libshiboken/helper.h +++ b/sources/shiboken2/libshiboken/helper.h @@ -60,7 +60,7 @@ namespace Shiboken * \note The argv array is allocated using new operator and each item is allocated using malloc. * \returns True on sucess, false otherwise. */ -LIBSHIBOKEN_API bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, const char* defaultAppName = 0); +LIBSHIBOKEN_API bool listToArgcArgv(PyObject *argList, int *argc, char ***argv, const char *defaultAppName = nullptr); /** * Convert a python sequence into a heap-allocated array of ints. @@ -68,7 +68,7 @@ LIBSHIBOKEN_API bool listToArgcArgv(PyObject* argList, int* argc, char*** argv, * \returns The newly allocated array or NULL in case of error or empty sequence. Check with PyErr_Occurred * if it was successfull. */ -LIBSHIBOKEN_API int* sequenceToIntArray(PyObject* obj, bool zeroTerminated = false); +LIBSHIBOKEN_API int *sequenceToIntArray(PyObject *obj, bool zeroTerminated = false); /** * Creates and automatically deallocates C++ arrays. @@ -77,17 +77,17 @@ template class AutoArrayPointer { public: - AutoArrayPointer(const AutoArrayPointer&) = delete; - AutoArrayPointer(AutoArrayPointer&&) = delete; - AutoArrayPointer& operator=(const AutoArrayPointer&) = delete; - AutoArrayPointer& operator=(AutoArrayPointer&&) = delete; + AutoArrayPointer(const AutoArrayPointer &) = delete; + AutoArrayPointer(AutoArrayPointer &&) = delete; + AutoArrayPointer &operator=(const AutoArrayPointer &) = delete; + AutoArrayPointer &operator=(AutoArrayPointer &&) = delete; explicit AutoArrayPointer(int size) { data = new T[size]; } - T& operator[](int pos) { return data[pos]; } - operator T*() const { return data; } + T &operator[](int pos) { return data[pos]; } + operator T *() const { return data; } ~AutoArrayPointer() { delete[] data; } private: - T* data; + T *data; }; typedef unsigned long long ThreadId; @@ -97,7 +97,7 @@ LIBSHIBOKEN_API ThreadId mainThreadId(); /** * An utility function used to call PyErr_WarnEx with a formatted message. */ -LIBSHIBOKEN_API int warning(PyObject* category, int stacklevel, const char* format, ...); +LIBSHIBOKEN_API int warning(PyObject *category, int stacklevel, const char *format, ...); } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/pep384_issue33738.cpp b/sources/shiboken2/libshiboken/pep384_issue33738.cpp index ee085438e..c20edeefa 100644 --- a/sources/shiboken2/libshiboken/pep384_issue33738.cpp +++ b/sources/shiboken2/libshiboken/pep384_issue33738.cpp @@ -114,7 +114,7 @@ typedef struct _oldtypeobject { int PyIndex_Check(PyObject *obj) { - PyOldTypeObject *type = reinterpret_cast(Py_TYPE(obj)); + PyOldTypeObject *type = reinterpret_cast(Py_TYPE(obj)); return type->tp_as_number != NULL && type->tp_as_number->nb_index != NULL; } diff --git a/sources/shiboken2/libshiboken/pep384impl.cpp b/sources/shiboken2/libshiboken/pep384impl.cpp index 9a52603dc..ac0328b6b 100644 --- a/sources/shiboken2/libshiboken/pep384impl.cpp +++ b/sources/shiboken2/libshiboken/pep384impl.cpp @@ -59,8 +59,8 @@ extern "C" * appear at the right offsets. */ -#define make_dummy_int(x) (x * sizeof(void*)) -#define make_dummy(x) (reinterpret_cast(make_dummy_int(x))) +#define make_dummy_int(x) (x * sizeof(void *)) +#define make_dummy(x) (reinterpret_cast(make_dummy_int(x))) #ifdef Py_LIMITED_API datetime_struc *PyDateTimeAPI = NULL; diff --git a/sources/shiboken2/libshiboken/python25compat.h b/sources/shiboken2/libshiboken/python25compat.h index fc25aa3e5..b8a4950d9 100644 --- a/sources/shiboken2/libshiboken/python25compat.h +++ b/sources/shiboken2/libshiboken/python25compat.h @@ -48,9 +48,9 @@ */ #if PY_VERSION_HEX < 0x02060000 -#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) -#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) -#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) +#define Py_REFCNT(ob) (((PyObject *)(ob))->ob_refcnt) +#define Py_TYPE(ob) (((PyObject *)(ob))->ob_type) +#define Py_SIZE(ob) (((PyVarObject *)(ob))->ob_size) #define PyVarObject_HEAD_INIT(type, size) \ PyObject_HEAD_INIT(type) size, #define PyType_Modified(t) @@ -90,7 +90,7 @@ typedef struct { #define PyBytes_Concat PyString_Concat #define PyBytes_Size PyString_Size -inline PyObject* PyUnicode_FromString(const char* s) +inline PyObject *PyUnicode_FromString(const char *s) { std::size_t len = std::strlen(s); return PyUnicode_DecodeUTF8(s, len, 0); diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter.h b/sources/shiboken2/libshiboken/sbkarrayconverter.h index 2b82b25b4..5b26c6e3c 100644 --- a/sources/shiboken2/libshiboken/sbkarrayconverter.h +++ b/sources/shiboken2/libshiboken/sbkarrayconverter.h @@ -74,7 +74,7 @@ template class ArrayHandle { ArrayHandle(const ArrayHandle &) = delete; - ArrayHandle& operator=(const ArrayHandle &) = delete; + ArrayHandle &operator=(const ArrayHandle &) = delete; public: ArrayHandle() {} ~ArrayHandle() { destroy(); } @@ -84,7 +84,7 @@ public: size_t size() const { return m_size; } T *data() const { return m_data; } - operator T*() const { return m_data; } + operator T *() const { return m_data; } private: void destroy(); @@ -108,7 +108,7 @@ public: Array2Handle() {} - operator RowType*() const { return m_rows; } + operator RowType *() const { return m_rows; } void setData(RowType *d) { m_rows = d; } diff --git a/sources/shiboken2/libshiboken/sbkarrayconverter_p.h b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h index a5e003e9a..a7b46702b 100644 --- a/sources/shiboken2/libshiboken/sbkarrayconverter_p.h +++ b/sources/shiboken2/libshiboken/sbkarrayconverter_p.h @@ -46,7 +46,7 @@ extern "C" { -typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject*, int dim1, int dim2); +typedef PythonToCppFunc (*IsArrayConvertibleToCppFunc)(PyObject *, int dim1, int dim2); /** * \internal * Private structure of SbkArrayConverter. diff --git a/sources/shiboken2/libshiboken/sbkconverter.cpp b/sources/shiboken2/libshiboken/sbkconverter.cpp index 4f6ebf65f..15afd5933 100644 --- a/sources/shiboken2/libshiboken/sbkconverter.cpp +++ b/sources/shiboken2/libshiboken/sbkconverter.cpp @@ -49,7 +49,7 @@ #include -static SbkConverter** PrimitiveTypeConverters; +static SbkConverter **PrimitiveTypeConverters; typedef std::unordered_map ConvertersMap; static ConvertersMap converters; @@ -61,11 +61,11 @@ void initArrayConverters(); void init() { - static SbkConverter* primitiveTypeConverters[] = { + static SbkConverter *primitiveTypeConverters[] = { Primitive::createConverter(), Primitive::createConverter(), Primitive::createConverter(), - Primitive::createConverter(), + Primitive::createConverter(), Primitive::createConverter(), Primitive::createConverter(), Primitive::createConverter(), @@ -112,7 +112,7 @@ SbkConverter *createConverterObject(PyTypeObject *type, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc) { - SbkConverter* converter = new SbkConverter; + auto converter = new SbkConverter; converter->pythonType = type; // PYSIDE-595: All types are heaptypes now, so provide reference. Py_XINCREF(type); @@ -127,7 +127,7 @@ SbkConverter *createConverterObject(PyTypeObject *type, return converter; } -SbkConverter* createConverter(SbkObjectType* type, +SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, @@ -141,12 +141,12 @@ SbkConverter* createConverter(SbkObjectType* type, return converter; } -SbkConverter* createConverter(PyTypeObject* type, CppToPythonFunc toPythonFunc) +SbkConverter *createConverter(PyTypeObject *type, CppToPythonFunc toPythonFunc) { return createConverterObject(type, 0, 0, 0, toPythonFunc); } -void deleteConverter(SbkConverter* converter) +void deleteConverter(SbkConverter *converter) { if (converter) { converter->toCppConversions.clear(); @@ -154,37 +154,37 @@ void deleteConverter(SbkConverter* converter) } } -void setCppPointerToPythonFunction(SbkConverter* converter, CppToPythonFunc pointerToPythonFunc) +void setCppPointerToPythonFunction(SbkConverter *converter, CppToPythonFunc pointerToPythonFunc) { converter->pointerToPython = pointerToPythonFunc; } -void setPythonToCppPointerFunctions(SbkConverter* converter, +void setPythonToCppPointerFunctions(SbkConverter *converter, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc) { converter->toCppPointerConversion = std::make_pair(toCppPointerCheckFunc, toCppPointerConvFunc); } -void addPythonToCppValueConversion(SbkConverter* converter, +void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { converter->toCppConversions.push_back(std::make_pair(isConvertibleToCppFunc, pythonToCppFunc)); } -void addPythonToCppValueConversion(SbkObjectType* type, +void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { addPythonToCppValueConversion(PepType_SOTP(type)->converter, pythonToCppFunc, isConvertibleToCppFunc); } -PyObject* pointerToPython(SbkObjectType *type, const void *cppIn) +PyObject *pointerToPython(SbkObjectType *type, const void *cppIn) { return pointerToPython(PepType_SOTP(type)->converter, cppIn); } -PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn) +PyObject *pointerToPython(const SbkConverter *converter, const void *cppIn) { assert(converter); if (!cppIn) @@ -197,12 +197,12 @@ PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn) return converter->pointerToPython(cppIn); } -PyObject* referenceToPython(SbkObjectType *type, const void *cppIn) +PyObject *referenceToPython(SbkObjectType *type, const void *cppIn) { return referenceToPython(PepType_SOTP(type)->converter, cppIn); } -PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn) +PyObject *referenceToPython(const SbkConverter *converter, const void *cppIn) { assert(cppIn); @@ -219,7 +219,7 @@ PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn) return converter->pointerToPython(cppIn); } -static inline PyObject* CopyCppToPython(const SbkConverter *converter, const void *cppIn) +static inline PyObject *CopyCppToPython(const SbkConverter *converter, const void *cppIn) { if (!cppIn) Py_RETURN_NONE; @@ -230,11 +230,11 @@ static inline PyObject* CopyCppToPython(const SbkConverter *converter, const voi } return converter->copyToPython(cppIn); } -PyObject* copyToPython(SbkObjectType *type, const void *cppIn) +PyObject *copyToPython(SbkObjectType *type, const void *cppIn) { return CopyCppToPython(PepType_SOTP(type)->converter, cppIn); } -PyObject* copyToPython(const SbkConverter *converter, const void *cppIn) +PyObject *copyToPython(const SbkConverter *converter, const void *cppIn) { return CopyCppToPython(converter, cppIn); } @@ -284,13 +284,13 @@ PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject return isPythonToCppValueConvertible(type, pyIn); } -void nonePythonToCppNullPtr(PyObject*, void* cppOut) +void nonePythonToCppNullPtr(PyObject *, void *cppOut) { assert(cppOut); - *((void**)cppOut) = 0; + *reinterpret_cast(cppOut) = nullptr; } -void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn) +void *cppPointer(PyTypeObject *desiredType, SbkObject *pyIn) { assert(pyIn); if (!ObjectType::checkType(desiredType)) @@ -301,7 +301,7 @@ void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn) return Object::cppPointer(pyIn, desiredType); } -void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut) +void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut) { assert(type); assert(pyIn); @@ -365,14 +365,14 @@ bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCppFunc) return toCppFunc != (*conv).second; } -void registerConverterName(SbkConverter* converter , const char* typeName) +void registerConverterName(SbkConverter *converter , const char *typeName) { ConvertersMap::iterator iter = converters.find(typeName); if (iter == converters.end()) converters.insert(std::make_pair(typeName, converter)); } -SbkConverter* getConverter(const char* typeName) +SbkConverter *getConverter(const char *typeName) { ConvertersMap::const_iterator it = converters.find(typeName); if (it != converters.end()) @@ -382,12 +382,12 @@ SbkConverter* getConverter(const char* typeName) return 0; } -SbkConverter* primitiveTypeConverter(int index) +SbkConverter *primitiveTypeConverter(int index) { return PrimitiveTypeConverters[index]; } -bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn) +bool checkSequenceTypes(PyTypeObject *type, PyObject *pyIn) { assert(type); assert(pyIn); @@ -422,7 +422,7 @@ bool convertibleSequenceTypes(SbkObjectType *type, PyObject *pyIn) return convertibleSequenceTypes(PepType_SOTP(type)->converter, pyIn); } -bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject* pyIn) +bool checkPairTypes(PyTypeObject *firstType, PyTypeObject *secondType, PyObject *pyIn) { assert(firstType); assert(secondType); @@ -466,7 +466,7 @@ bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExa return true; } -bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* pyIn) +bool checkDictTypes(PyTypeObject *keyType, PyTypeObject *valueType, PyObject *pyIn) { assert(keyType); assert(valueType); @@ -474,8 +474,8 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py if (!PyDict_Check(pyIn)) return false; - PyObject* key; - PyObject* value; + PyObject *key; + PyObject *value; Py_ssize_t pos = 0; while (PyDict_Next(pyIn, &pos, &key, &value)) { if (!PyObject_TypeCheck(key, keyType)) @@ -486,7 +486,7 @@ bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* py return true; } -bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, const SbkConverter *valueConverter, +bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact, const SbkConverter *valueConverter, bool valueCheckExact, PyObject *pyIn) { assert(keyConverter); @@ -494,8 +494,8 @@ bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, assert(pyIn); if (!PyDict_Check(pyIn)) return false; - PyObject* key; - PyObject* value; + PyObject *key; + PyObject *value; Py_ssize_t pos = 0; while (PyDict_Next(pyIn, &pos, &key, &value)) { if (keyCheckExact) { @@ -514,14 +514,14 @@ bool convertibleDictTypes(const SbkConverter * keyConverter, bool keyCheckExact, return true; } -PyTypeObject* getPythonTypeObject(const SbkConverter *converter) +PyTypeObject *getPythonTypeObject(const SbkConverter *converter) { if (converter) return converter->pythonType; return 0; } -PyTypeObject* getPythonTypeObject(const char* typeName) +PyTypeObject *getPythonTypeObject(const char *typeName) { return getPythonTypeObject(getConverter(typeName)); } @@ -545,7 +545,7 @@ bool pythonTypeIsWrapperType(const SbkConverter *converter) return converter->pointerToPython != 0; } -SpecificConverter::SpecificConverter(const char* typeName) +SpecificConverter::SpecificConverter(const char *typeName) : m_type(InvalidConversion) { m_converter = getConverter(typeName); @@ -562,13 +562,13 @@ SpecificConverter::SpecificConverter(const char* typeName) } } -PyObject* SpecificConverter::toPython(const void* cppIn) +PyObject *SpecificConverter::toPython(const void *cppIn) { switch (m_type) { case CopyConversion: return copyToPython(m_converter, cppIn); case PointerConversion: - return pointerToPython(m_converter, *((const void**)cppIn)); + return pointerToPython(m_converter, *((const void **)cppIn)); case ReferenceConversion: return referenceToPython(m_converter, cppIn); default: @@ -577,7 +577,7 @@ PyObject* SpecificConverter::toPython(const void* cppIn) return 0; } -void SpecificConverter::toCpp(PyObject* pyIn, void* cppOut) +void SpecificConverter::toCpp(PyObject *pyIn, void *cppOut) { switch (m_type) { case CopyConversion: diff --git a/sources/shiboken2/libshiboken/sbkconverter.h b/sources/shiboken2/libshiboken/sbkconverter.h index 33c33025b..2d1735f2b 100644 --- a/sources/shiboken2/libshiboken/sbkconverter.h +++ b/sources/shiboken2/libshiboken/sbkconverter.h @@ -77,7 +77,7 @@ struct SbkArrayConverter; * * C++ -> Python */ -typedef PyObject* (*CppToPythonFunc)(const void*); +typedef PyObject *(*CppToPythonFunc)(const void *); /** * This function converts a Python object to a C++ value, it may be @@ -90,7 +90,7 @@ typedef PyObject* (*CppToPythonFunc)(const void*); * * Python -> C++ */ -typedef void (*PythonToCppFunc)(PyObject*,void*); +typedef void (*PythonToCppFunc)(PyObject *,void *); /** * Checks if the Python object passed in the argument is convertible to a @@ -101,7 +101,7 @@ typedef void (*PythonToCppFunc)(PyObject*,void*); * * Python -> C++ ? */ -typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject*); +typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *); } // extern "C" @@ -120,20 +120,20 @@ public: ReferenceConversion }; - explicit SpecificConverter(const char* typeName); + explicit SpecificConverter(const char *typeName); - inline SbkConverter* converter() { return m_converter; } - inline operator SbkConverter*() const { return m_converter; } + inline SbkConverter *converter() { return m_converter; } + inline operator SbkConverter *() const { return m_converter; } inline bool isValid() { return m_type != InvalidConversion; } inline operator bool() const { return m_type != InvalidConversion; } inline Type conversionType() { return m_type; } - PyObject* toPython(const void* cppIn); - void toCpp(PyObject* pyIn, void* cppOut); + PyObject *toPython(const void *cppIn); + void toCpp(PyObject *pyIn, void *cppOut); private: - SbkConverter* m_converter; + SbkConverter *m_converter; Type m_type; }; @@ -147,7 +147,7 @@ private: * \param copyToPythonFunc Function to convert a C++ object to a Python \p type, copying the object. * \returns The new converter referred by the wrapper \p type. */ -LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type, +LIBSHIBOKEN_API SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, @@ -159,15 +159,15 @@ LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type, * \param toPythonFunc Function to convert a C++ object to a Python \p type. * \returns A new type converter. */ -LIBSHIBOKEN_API SbkConverter* createConverter(PyTypeObject* type, CppToPythonFunc toPythonFunc); +LIBSHIBOKEN_API SbkConverter *createConverter(PyTypeObject *type, CppToPythonFunc toPythonFunc); -LIBSHIBOKEN_API void deleteConverter(SbkConverter* converter); +LIBSHIBOKEN_API void deleteConverter(SbkConverter *converter); /// Sets the Python object to C++ pointer conversion function. -LIBSHIBOKEN_API void setCppPointerToPythonFunction(SbkConverter* converter, CppToPythonFunc pointerToPythonFunc); +LIBSHIBOKEN_API void setCppPointerToPythonFunction(SbkConverter *converter, CppToPythonFunc pointerToPythonFunc); /// Sets the C++ pointer to Python object conversion functions. -LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter* converter, +LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter *converter, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc); @@ -175,10 +175,10 @@ LIBSHIBOKEN_API void setPythonToCppPointerFunctions(SbkConverter* converter, * Adds a new conversion of a Python object to a C++ value. * This is used in copy and implicit conversions. */ -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter* converter, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); @@ -188,11 +188,11 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, * Retrieves the Python wrapper object for the given \p cppIn C++ pointer object. * This function is used only for Value and Object Types. * Example usage: - * TYPE* var; - * PyObject* pyVar = pointerToPython(SBKTYPE, &var); + * TYPE *var; + * PyObject *pyVar = pointerToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType *type, const void *cppIn); -LIBSHIBOKEN_API PyObject* pointerToPython(const SbkConverter *converter, const void *cppIn); +LIBSHIBOKEN_API PyObject *pointerToPython(SbkObjectType *type, const void *cppIn); +LIBSHIBOKEN_API PyObject *pointerToPython(const SbkConverter *converter, const void *cppIn); /** * For the given \p cppIn C++ reference it returns the Python wrapper object, @@ -200,21 +200,21 @@ LIBSHIBOKEN_API PyObject* pointerToPython(const SbkConverter *converter, const v * for when the latter doesn't have an existing wrapper type, the C++ object * is copied to Python. * Example usage: - * TYPE& var = SOMETHING; - * PyObject* pyVar = referenceToPython(SBKTYPE, &var); + * TYPE &var = SOMETHING; + * PyObject *pyVar = referenceToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType *type, const void *cppIn); -LIBSHIBOKEN_API PyObject* referenceToPython(const SbkConverter *converter, const void *cppIn); +LIBSHIBOKEN_API PyObject *referenceToPython(SbkObjectType *type, const void *cppIn); +LIBSHIBOKEN_API PyObject *referenceToPython(const SbkConverter *converter, const void *cppIn); /** * Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn. * This function is used only for Value Types. * Example usage: * TYPE var; - * PyObject* pyVar = copyToPython(SBKTYPE, &var); + * PyObject *pyVar = copyToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType *type, const void *cppIn); -LIBSHIBOKEN_API PyObject* copyToPython(const SbkConverter *converter, const void *cppIn); +LIBSHIBOKEN_API PyObject *copyToPython(SbkObjectType *type, const void *cppIn); +LIBSHIBOKEN_API PyObject *copyToPython(const SbkConverter *converter, const void *cppIn); // Python -> C++ --------------------------------------------------------------------------- @@ -250,10 +250,10 @@ LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(const SbkArrayConverter * It differs from Shiboken::Object::cppPointer because it casts the pointer to a proper * memory offset depending on the desired type. */ -LIBSHIBOKEN_API void* cppPointer(PyTypeObject* desiredType, SbkObject* pyIn); +LIBSHIBOKEN_API void *cppPointer(PyTypeObject *desiredType, SbkObject *pyIn); /// Converts a Python object \p pyIn to C++ and stores the result in the C++ pointer passed in \p cppOut. -LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut); +LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut); LIBSHIBOKEN_API void pythonToCppPointer(const SbkConverter *converter, PyObject *pyIn, void *cppOut); /// Converts a Python object \p pyIn to C++, and copies the result in the C++ variable passed in \p cppOut. @@ -264,7 +264,7 @@ LIBSHIBOKEN_API void pythonToCppCopy(const SbkConverter *converter, PyObject *py * Helper function returned by generated convertible checking functions * that returns a C++ NULL when the input Python object is None. */ -LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut); +LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject *, void *cppOut); /** * Returns true if the \p toCpp function passed is an implicit conversion of Python \p type. @@ -274,16 +274,16 @@ LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut); LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCpp); /// Registers a converter with a type name that may be used to retrieve the converter. -LIBSHIBOKEN_API void registerConverterName(SbkConverter* converter, const char* typeName); +LIBSHIBOKEN_API void registerConverterName(SbkConverter *converter, const char *typeName); /// Returns the converter for a given type name, or NULL if it wasn't registered before. -LIBSHIBOKEN_API SbkConverter* getConverter(const char* typeName); +LIBSHIBOKEN_API SbkConverter *getConverter(const char *typeName); /// Returns the converter for a primitive type. -LIBSHIBOKEN_API SbkConverter* primitiveTypeConverter(int index); +LIBSHIBOKEN_API SbkConverter *primitiveTypeConverter(int index); /// Returns true if a Python sequence is comprised of objects of the given \p type. -LIBSHIBOKEN_API bool checkSequenceTypes(PyTypeObject* type, PyObject* pyIn); +LIBSHIBOKEN_API bool checkSequenceTypes(PyTypeObject *type, PyObject *pyIn); /// Returns true if a Python sequence is comprised of objects of a type convertible to the one represented by the given \p converter. LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyObject *pyIn); @@ -292,7 +292,7 @@ LIBSHIBOKEN_API bool convertibleSequenceTypes(const SbkConverter *converter, PyO LIBSHIBOKEN_API bool convertibleSequenceTypes(SbkObjectType *type, PyObject *pyIn); /// Returns true if a Python sequence can be converted to a C++ pair. -LIBSHIBOKEN_API bool checkPairTypes(PyTypeObject* firstType, PyTypeObject* secondType, PyObject* pyIn); +LIBSHIBOKEN_API bool checkPairTypes(PyTypeObject *firstType, PyTypeObject *secondType, PyObject *pyIn); /// Returns true if a Python sequence can be converted to a C++ pair. LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bool firstCheckExact, @@ -300,7 +300,7 @@ LIBSHIBOKEN_API bool convertiblePairTypes(const SbkConverter *firstConverter, bo PyObject *pyIn); /// Returns true if a Python dictionary can be converted to a C++ hash or map. -LIBSHIBOKEN_API bool checkDictTypes(PyTypeObject* keyType, PyTypeObject* valueType, PyObject* pyIn); +LIBSHIBOKEN_API bool checkDictTypes(PyTypeObject *keyType, PyTypeObject *valueType, PyObject *pyIn); /// Returns true if a Python dictionary can be converted to a C++ hash or map. LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool keyCheckExact, @@ -308,10 +308,10 @@ LIBSHIBOKEN_API bool convertibleDictTypes(const SbkConverter *keyConverter, bool PyObject *pyIn); /// Returns the Python type object associated with the given \p converter. -LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const SbkConverter *converter); +LIBSHIBOKEN_API PyTypeObject *getPythonTypeObject(const SbkConverter *converter); /// Returns the Python type object for the given \p typeName. -LIBSHIBOKEN_API PyTypeObject* getPythonTypeObject(const char* typeName); +LIBSHIBOKEN_API PyTypeObject *getPythonTypeObject(const char *typeName); /// Returns true if the Python type associated with the converter is a value type. LIBSHIBOKEN_API bool pythonTypeIsValueType(const SbkConverter *converter); @@ -343,25 +343,25 @@ LIBSHIBOKEN_API bool pythonTypeIsWrapperType(const SbkConverter *converter); #define SBK_VOIDPTR_IDX 16 #define SBK_NULLPTR_T_IDX 17 -template SbkConverter* PrimitiveTypeConverter() { return 0; } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_PY_LONG_LONG_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_BOOL_IDX_1); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_CHAR_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_CONSTCHARPTR_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_DOUBLE_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_FLOAT_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_INT_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_LONG_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_SHORT_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_SIGNEDCHAR_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_STD_STRING_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDPY_LONG_LONG_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDCHAR_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDINT_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDLONG_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDSHORT_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_VOIDPTR_IDX); } -template<> inline SbkConverter* PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_NULLPTR_T_IDX); } +template SbkConverter *PrimitiveTypeConverter() { return 0; } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_PY_LONG_LONG_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_BOOL_IDX_1); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_CHAR_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_CONSTCHARPTR_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_DOUBLE_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_FLOAT_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_INT_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_LONG_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_SHORT_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_SIGNEDCHAR_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_STD_STRING_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDPY_LONG_LONG_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDCHAR_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDINT_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDLONG_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_UNSIGNEDSHORT_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_VOIDPTR_IDX); } +template<> inline SbkConverter *PrimitiveTypeConverter() { return primitiveTypeConverter(SBK_NULLPTR_T_IDX); } } // namespace Shiboken::Conversions @@ -371,24 +371,24 @@ template<> inline SbkConverter* PrimitiveTypeConverter() { retur * T isn't a C++ primitive type. * \see SpecialCastFunction */ -template PyTypeObject* SbkType() { return 0; } +template PyTypeObject *SbkType() { return 0; } // Below are the template specializations for C++ primitive types. -template<> inline PyTypeObject* SbkType() { return &PyLong_Type; } -template<> inline PyTypeObject* SbkType() { return &PyBool_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return &PyFloat_Type; } -template<> inline PyTypeObject* SbkType() { return &PyFloat_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return &PyLong_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return &PyLong_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return &PyLong_Type; } -template<> inline PyTypeObject* SbkType() { return &PyLong_Type; } -template<> inline PyTypeObject* SbkType() { return &PyInt_Type; } -template<> inline PyTypeObject* SbkType() { return Py_TYPE(&_Py_NoneStruct); } +template<> inline PyTypeObject *SbkType() { return &PyLong_Type; } +template<> inline PyTypeObject *SbkType() { return &PyBool_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return &PyFloat_Type; } +template<> inline PyTypeObject *SbkType() { return &PyFloat_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return &PyLong_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return &PyLong_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return &PyLong_Type; } +template<> inline PyTypeObject *SbkType() { return &PyLong_Type; } +template<> inline PyTypeObject *SbkType() { return &PyInt_Type; } +template<> inline PyTypeObject *SbkType() { return Py_TYPE(&_Py_NoneStruct); } } // namespace Shiboken @@ -398,7 +398,7 @@ template<> inline PyTypeObject* SbkType() { return Py_TYPE(&_Py_ #define SbkChar_Check(X) (SbkNumber_Check(X) || Shiboken::String::checkChar(X)) struct _SbkGenericTypePrivate { - SbkConverter** converter; + SbkConverter **converter; }; diff --git a/sources/shiboken2/libshiboken/sbkconverter_p.h b/sources/shiboken2/libshiboken/sbkconverter_p.h index cb968ed89..aa90094af 100644 --- a/sources/shiboken2/libshiboken/sbkconverter_p.h +++ b/sources/shiboken2/libshiboken/sbkconverter_p.h @@ -69,7 +69,7 @@ struct SbkConverter * Python type to which the C++ value will be converted (note that the * C++ type could be produced from various Python types). */ - PyTypeObject* pythonType; + PyTypeObject *pythonType; /** * This function converts a C++ object to a Python object of the type * indicated in pythonType. The identity of the C++ object is kept, @@ -77,7 +77,7 @@ struct SbkConverter * with the C++ instance. * It is used to convert C++ pointers and references to Python objects. */ - CppToPythonFunc pointerToPython; + CppToPythonFunc pointerToPython; /** * This function converts a C++ object to a Python object of the type * indicated in pythonType. The identity of the object is not kept, @@ -86,17 +86,17 @@ struct SbkConverter * reference can't be traced to an object that already has a Python * wrapper assigned for it. */ - CppToPythonFunc copyToPython; + CppToPythonFunc copyToPython; /** * This is a special case of a Python to C++ conversion. It returns * the underlying C++ pointer of a Python wrapper passed as parameter * or NULL if the Python object is a None value. * It comes separated from the other toCppConversions because if you * have a Python object representing a Value Type the type checking - * for both ValueType and ValueType* would be the same, thus the first + * for both ValueType and ValueType *would be the same, thus the first * check would be true and the second would never be reached. */ - ToCppConversion toCppPointerConversion; + ToCppConversion toCppPointerConversion; /** * This is a list of type checking functions that return the * proper Python to C++ conversion function, for the given Python @@ -104,14 +104,14 @@ struct SbkConverter * For Object Types, that never have implicit conversions, this * list is always empty. */ - ToCppConversionVector toCppConversions; + ToCppConversionVector toCppConversions; }; } // extern "C" template struct OverFlowCheckerBase { - static void formatOverFlowMessage(const MaxLimitType& value, + static void formatOverFlowMessage(const MaxLimitType &value, const std::string *valueAsString = 0) { std::ostringstream str; @@ -157,7 +157,7 @@ struct OverFlowChecker; template struct OverFlowChecker : public OverFlowCheckerBase { - static bool check(const MaxLimitType& value, PyObject *pyIn) + static bool check(const MaxLimitType &value, PyObject *pyIn) { std::string valueAsString; const bool isOverflow = @@ -173,7 +173,7 @@ struct OverFlowChecker : template struct OverFlowChecker : public OverFlowCheckerBase { - static bool check(const MaxLimitType& value, PyObject *pyIn) + static bool check(const MaxLimitType &value, PyObject *pyIn) { std::string valueAsString; const bool isOverflow = @@ -204,7 +204,7 @@ struct OverFlowChecker { template<> struct OverFlowChecker : public OverFlowCheckerBase { - static bool check(const double& value, PyObject *) + static bool check(const double &value, PyObject *) { const bool result = value < std::numeric_limits::min() || value > std::numeric_limits::max(); @@ -221,12 +221,12 @@ template struct Primitive {}; template struct OnePrimitive { - static PyObject* toPython(const void*) { return 0; } - static PythonToCppFunc isConvertible(PyObject*) { return 0; } - static void toCpp(PyObject*, void*) {} - static SbkConverter* createConverter() + static PyObject *toPython(const void *) { return nullptr; } + static PythonToCppFunc isConvertible(PyObject *) { return nullptr; } + static void toCpp(PyObject *, void *) {} + static SbkConverter *createConverter() { - SbkConverter* converter = Shiboken::Conversions::createConverter(Shiboken::SbkType(), + SbkConverter *converter = Shiboken::Conversions::createConverter(Shiboken::SbkType(), Primitive::toPython); Shiboken::Conversions::addPythonToCppValueConversion(converter, Primitive::toCpp, @@ -237,11 +237,11 @@ struct OnePrimitive template struct TwoPrimitive : OnePrimitive { - static PythonToCppFunc isOtherConvertible(PyObject*) { return 0; } - static void otherToCpp(PyObject*, void*) {} - static SbkConverter* createConverter() + static PythonToCppFunc isOtherConvertible(PyObject *) { return nullptr; } + static void otherToCpp(PyObject *, void *) {} + static SbkConverter *createConverter() { - SbkConverter* converter = OnePrimitive::createConverter(); + SbkConverter *converter = OnePrimitive::createConverter(); Shiboken::Conversions::addPythonToCppValueConversion(converter, Primitive::otherToCpp, Primitive::isOtherConvertible); return converter; } @@ -252,11 +252,11 @@ struct TwoPrimitive : OnePrimitive template struct IntPrimitive : TwoPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { return PyInt_FromLong(*reinterpret_cast(cppIn)); } - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { double result = PyFloat_AS_DOUBLE(pyIn); // If cast to long directly it could overflow silently. @@ -264,20 +264,20 @@ struct IntPrimitive : TwoPrimitive PyErr_SetObject(PyExc_OverflowError, 0); *reinterpret_cast(cppOut) = static_cast(result); } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (PyFloat_Check(pyIn)) return toCpp; return 0; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { PY_LONG_LONG result = PyLong_AsLongLong(pyIn); if (OverFlowChecker::check(result, pyIn)) PyErr_SetObject(PyExc_OverflowError, 0); *reinterpret_cast(cppOut) = static_cast(result); } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return otherToCpp; @@ -294,7 +294,7 @@ template <> struct Primitive : IntPrimitive {}; template struct UnsignedLongPrimitive : IntPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { return PyLong_FromUnsignedLong(*reinterpret_cast(cppIn)); } @@ -307,18 +307,18 @@ template <> struct Primitive : UnsignedLongPrimitive struct Primitive : OnePrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { - return PyLong_FromLongLong(*((PY_LONG_LONG*)cppIn)); + return PyLong_FromLongLong(*reinterpret_cast(cppIn)); } - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { PY_LONG_LONG result = PyLong_AsLongLong(pyIn); if (OverFlowChecker::check(result, pyIn)) PyErr_SetObject(PyExc_OverflowError, 0); *reinterpret_cast(cppOut) = result; } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return toCpp; @@ -329,11 +329,11 @@ struct Primitive : OnePrimitive template <> struct Primitive : OnePrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { - return PyLong_FromUnsignedLongLong(*((unsigned PY_LONG_LONG*)cppIn)); + return PyLong_FromUnsignedLongLong(*reinterpret_cast(cppIn)); } - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(pyIn)) { @@ -362,7 +362,7 @@ struct Primitive : OnePrimitive } #endif // Python 2 } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return toCpp; @@ -375,25 +375,25 @@ struct Primitive : OnePrimitive template struct FloatPrimitive : TwoPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { return PyFloat_FromDouble(*reinterpret_cast(cppIn)); } - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { *reinterpret_cast(cppOut) = FLOAT(PyLong_AsLong(pyIn)); } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (PyInt_Check(pyIn) || PyLong_Check(pyIn)) return toCpp; return 0; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { *reinterpret_cast(cppOut) = FLOAT(PyFloat_AsDouble(pyIn)); } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return otherToCpp; @@ -408,17 +408,17 @@ template <> struct Primitive : FloatPrimitive {}; template <> struct Primitive : OnePrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { return PyBool_FromLong(*reinterpret_cast(cppIn)); } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return toCpp; return 0; } - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { *reinterpret_cast(cppOut) = PyInt_AS_LONG(pyIn) != 0; } @@ -429,32 +429,32 @@ struct Primitive : OnePrimitive template struct CharPrimitive : IntPrimitive { - static void toCpp(PyObject* pyIn, void* cppOut) + static void toCpp(PyObject *pyIn, void *cppOut) { *reinterpret_cast(cppOut) = CHAR(Shiboken::String::toCString(pyIn)[0]); } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (Shiboken::String::checkChar(pyIn)) return toCpp; return 0; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { PY_LONG_LONG result = PyLong_AsLongLong(pyIn); if (OverFlowChecker::check(result, pyIn)) PyErr_SetObject(PyExc_OverflowError, 0); *reinterpret_cast(cppOut) = CHAR(result); } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (SbkNumber_Check(pyIn)) return otherToCpp; return 0; } - static SbkConverter* createConverter() + static SbkConverter *createConverter() { - SbkConverter* converter = IntPrimitive::createConverter(); + SbkConverter *converter = IntPrimitive::createConverter(); Shiboken::Conversions::addPythonToCppValueConversion(converter, CharPrimitive::otherToCpp, CharPrimitive::isOtherConvertible); return converter; } @@ -464,8 +464,8 @@ template <> struct Primitive : CharPrimitive {}; template <> struct Primitive : CharPrimitive {}; template <> struct Primitive : CharPrimitive { using CharPrimitive::toPython; - static PyObject* toPython(const void* cppIn) { - return Shiboken::String::fromCString((const char*)cppIn, 1); + static PyObject *toPython(const void *cppIn) { + return Shiboken::String::fromCString(reinterpret_cast(cppIn), 1); } }; @@ -474,29 +474,29 @@ template <> struct Primitive : CharPrimitive { // Strings --------------------------------------------------------------------------------- template <> -struct Primitive : TwoPrimitive +struct Primitive : TwoPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { if (!cppIn) Py_RETURN_NONE; - return Shiboken::String::fromCString((const char*)cppIn); + return Shiboken::String::fromCString(reinterpret_cast(cppIn)); } static void toCpp(PyObject *, void *cppOut) { - *((const char**)cppOut) = 0; + *((const char **)cppOut) = 0; } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (pyIn == Py_None) return toCpp; return 0; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { - *((const char**)cppOut) = (const char*) Shiboken::String::toCString(pyIn); + *reinterpret_cast(cppOut) = Shiboken::String::toCString(pyIn); } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (Shiboken::String::check(pyIn)) return otherToCpp; @@ -507,25 +507,25 @@ struct Primitive : TwoPrimitive template <> struct Primitive : TwoPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { - return Shiboken::String::fromCString(((std::string*)cppIn)->c_str()); + return Shiboken::String::fromCString(reinterpret_cast(cppIn)->c_str()); } static void toCpp(PyObject *, void *cppOut) { - *((std::string*)cppOut) = std::string(); + reinterpret_cast(cppOut)->clear(); } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (pyIn == Py_None) return toCpp; return 0; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { - *((std::string*)cppOut) = Shiboken::String::toCString(pyIn); + reinterpret_cast(cppOut)->assign(Shiboken::String::toCString(pyIn)); } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (Shiboken::String::check(pyIn)) return otherToCpp; @@ -537,25 +537,25 @@ struct Primitive : TwoPrimitive template <> struct Primitive : TwoPrimitive { - static PyObject* toPython(const void* cppIn) + static PyObject *toPython(const void *cppIn) { return Py_None; } static void toCpp(PyObject *, void *cppOut) { - *reinterpret_cast(cppOut) = nullptr; + *reinterpret_cast(cppOut) = nullptr; } - static PythonToCppFunc isConvertible(PyObject* pyIn) + static PythonToCppFunc isConvertible(PyObject *pyIn) { if (pyIn == Py_None) return toCpp; return nullptr; } - static void otherToCpp(PyObject* pyIn, void* cppOut) + static void otherToCpp(PyObject *pyIn, void *cppOut) { - *reinterpret_cast(cppOut) = nullptr; + *reinterpret_cast(cppOut) = nullptr; } - static PythonToCppFunc isOtherConvertible(PyObject* pyIn) + static PythonToCppFunc isOtherConvertible(PyObject *pyIn) { if (pyIn == nullptr) return otherToCpp; diff --git a/sources/shiboken2/libshiboken/sbkdbg.h b/sources/shiboken2/libshiboken/sbkdbg.h index fdaf2a27a..02ea773ac 100644 --- a/sources/shiboken2/libshiboken/sbkdbg.h +++ b/sources/shiboken2/libshiboken/sbkdbg.h @@ -63,20 +63,20 @@ class BaseLogger { public: - BaseLogger(const BaseLogger&) = delete; - BaseLogger(BaseLogger&&) = delete; - BaseLogger& operator=(const BaseLogger&) = delete; - BaseLogger& operator=(BaseLogger&&) = delete; + BaseLogger(const BaseLogger &) = delete; + BaseLogger(BaseLogger &&) = delete; + BaseLogger &operator=(const BaseLogger &) = delete; + BaseLogger &operator=(BaseLogger &&) = delete; - BaseLogger(std::ostream& output, const char* function, const char* context) + BaseLogger(std::ostream &output, const char *function, const char *context) : m_stream(output), m_function(function), m_context(context) {} ~BaseLogger() { m_stream << std::endl; } - std::ostream& operator()() { return m_stream; }; + std::ostream &operator()() { return m_stream; }; template - std::ostream& operator<<(const T& t) + std::ostream &operator<<(const T &t) { m_stream << '['; if (m_context[0]) @@ -84,24 +84,24 @@ public: return m_stream << COLOR_WHITE << m_function << COLOR_END << "] " << t; } private: - std::ostream& m_stream; - const char* m_function; - const char* m_context; + std::ostream &m_stream; + const char *m_function; + const char *m_context; }; -inline std::ostream& operator<<(std::ostream& out, PyObject* obj) +inline std::ostream &operator<<(std::ostream &out, PyObject *obj) { - PyObject* repr = Shiboken::Object::isValid(obj, false) ? PyObject_Repr(obj) : 0; + PyObject *repr = Shiboken::Object::isValid(obj, false) ? PyObject_Repr(obj) : 0; if (repr) { #ifdef IS_PY3K - PyObject* str = PyUnicode_AsUTF8String(repr); + PyObject *str = PyUnicode_AsUTF8String(repr); Py_DECREF(repr); repr = str; #endif out << PyBytes_AS_STRING(repr); Py_DECREF(repr); } else { - out << reinterpret_cast(obj); + out << reinterpret_cast(obj); } return out; } @@ -109,7 +109,7 @@ inline std::ostream& operator<<(std::ostream& out, PyObject* obj) class _SbkDbg : public BaseLogger { public: - _SbkDbg(const char* function, const char* context = "") : BaseLogger(std::cout, function, context) {} + _SbkDbg(const char *function, const char *context = "") : BaseLogger(std::cout, function, context) {} }; #ifdef __GNUG__ @@ -122,7 +122,7 @@ public: struct SbkDbg { template - SbkDbg& operator<<(const T&) { return *this; } + SbkDbg &operator<<(const T &) { return *this; } }; #endif diff --git a/sources/shiboken2/libshiboken/sbkenum.cpp b/sources/shiboken2/libshiboken/sbkenum.cpp index 26b40c3cb..75054ab71 100644 --- a/sources/shiboken2/libshiboken/sbkenum.cpp +++ b/sources/shiboken2/libshiboken/sbkenum.cpp @@ -49,18 +49,18 @@ #include #include -#define SBK_ENUM(ENUM) reinterpret_cast(ENUM) +#define SBK_ENUM(ENUM) reinterpret_cast(ENUM) #define SBK_TYPE_CHECK(o) (strcmp(Py_TYPE(Py_TYPE(o))->tp_name, "Shiboken.EnumType") == 0) -typedef PyObject* (*enum_func)(PyObject*, PyObject*); +typedef PyObject *(*enum_func)(PyObject *, PyObject *); extern "C" { struct SbkEnumTypePrivate { - SbkConverter** converterPtr; - SbkConverter* converter; - const char* cppName; + SbkConverter **converterPtr; + SbkConverter *converter; + const char *cppName; }; struct SbkEnumType @@ -72,10 +72,10 @@ struct SbkEnumObject { PyObject_HEAD long ob_value; - PyObject* ob_name; + PyObject *ob_name; }; -static PyObject* SbkEnumObject_repr(PyObject* self) +static PyObject *SbkEnumObject_repr(PyObject *self) { const SbkEnumObject *enumObj = SBK_ENUM(self); if (enumObj->ob_name) @@ -84,7 +84,7 @@ static PyObject* SbkEnumObject_repr(PyObject* self) return Shiboken::String::fromFormat("%s(%ld)", (Py_TYPE(self))->tp_name, enumObj->ob_value); } -static PyObject* SbkEnumObject_name(PyObject* self, void*) +static PyObject *SbkEnumObject_name(PyObject *self, void *) { SbkEnumObject *enum_self = SBK_ENUM(self); @@ -95,27 +95,27 @@ static PyObject* SbkEnumObject_name(PyObject* self, void*) return enum_self->ob_name; } -static PyObject* SbkEnum_tp_new(PyTypeObject *type, PyObject *args, PyObject *) +static PyObject *SbkEnum_tp_new(PyTypeObject *type, PyObject *args, PyObject *) { long itemValue = 0; if (!PyArg_ParseTuple(args, "|l:__new__", &itemValue)) return 0; - SbkEnumObject* self = PyObject_New(SbkEnumObject, type); + SbkEnumObject *self = PyObject_New(SbkEnumObject, type); if (!self) return 0; self->ob_value = itemValue; - PyObject* item = Shiboken::Enum::getEnumItemFromValue(type, itemValue); + PyObject *item = Shiboken::Enum::getEnumItemFromValue(type, itemValue); if (item) { self->ob_name = SbkEnumObject_name(item, 0); Py_XDECREF(item); } else { self->ob_name = 0; } - return reinterpret_cast(self); + return reinterpret_cast(self); } -static PyObject* enum_op(enum_func f, PyObject *a, PyObject *b) { +static PyObject *enum_op(enum_func f, PyObject *a, PyObject *b) { PyObject *valA = a; PyObject *valB = b; PyObject *result = nullptr; @@ -160,54 +160,54 @@ static PyObject* enum_op(enum_func f, PyObject *a, PyObject *b) { * Thus calling PyInt_FromLong() will result in calling PyLong_FromLong in * Py3k. */ -static PyObject* enum_int(PyObject* v) +static PyObject *enum_int(PyObject *v) { return PyInt_FromLong(SBK_ENUM(v)->ob_value); } -static PyObject* enum_and(PyObject* self, PyObject* b) +static PyObject *enum_and(PyObject *self, PyObject *b) { return enum_op(PyNumber_And, self, b); } -static PyObject* enum_or(PyObject* self, PyObject* b) +static PyObject *enum_or(PyObject *self, PyObject *b) { return enum_op(PyNumber_Or, self, b); } -static PyObject* enum_xor(PyObject* self, PyObject* b) +static PyObject *enum_xor(PyObject *self, PyObject *b) { return enum_op(PyNumber_Xor, self, b); } -static int enum_bool(PyObject* v) +static int enum_bool(PyObject *v) { return (SBK_ENUM(v)->ob_value > 0); } -static PyObject* enum_add(PyObject* self, PyObject* v) +static PyObject *enum_add(PyObject *self, PyObject *v) { return enum_op(PyNumber_Add, self, v); } -static PyObject* enum_subtract(PyObject* self, PyObject* v) +static PyObject *enum_subtract(PyObject *self, PyObject *v) { return enum_op(PyNumber_Subtract, self, v); } -static PyObject* enum_multiply(PyObject* self, PyObject* v) +static PyObject *enum_multiply(PyObject *self, PyObject *v) { return enum_op(PyNumber_Multiply, self, v); } #ifndef IS_PY3K -static PyObject* enum_divide(PyObject* self, PyObject* v) +static PyObject *enum_divide(PyObject *self, PyObject *v) { return enum_op(PyNumber_Divide, self, v); } #endif -static PyObject* enum_richcompare(PyObject* self, PyObject* other, int op) +static PyObject *enum_richcompare(PyObject *self, PyObject *other, int op) { PyObject *valA = self; PyObject *valB = other; @@ -246,21 +246,21 @@ static PyObject* enum_richcompare(PyObject* self, PyObject* other, int op) return result; } -static Py_hash_t enum_hash(PyObject* pyObj) +static Py_hash_t enum_hash(PyObject *pyObj) { - Py_hash_t val = reinterpret_cast(pyObj)->ob_value; + Py_hash_t val = reinterpret_cast(pyObj)->ob_value; if (val == -1) val = -2; return val; } static PyGetSetDef SbkEnumGetSetList[] = { - {const_cast("name"), &SbkEnumObject_name, 0, 0, 0}, + {const_cast("name"), &SbkEnumObject_name, nullptr, nullptr, nullptr}, {0, 0, 0, 0, 0} // Sentinel }; -static void SbkEnumTypeDealloc(PyObject* pyObj); -static PyObject* SbkEnumTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds); +static void SbkEnumTypeDealloc(PyObject *pyObj); +static PyObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds); static PyType_Slot SbkEnumType_Type_slots[] = { {Py_tp_dealloc, (void *)SbkEnumTypeDealloc}, @@ -308,9 +308,9 @@ PyTypeObject *SbkEnumType_TypeF(void) return type; } -void SbkEnumTypeDealloc(PyObject* pyObj) +void SbkEnumTypeDealloc(PyObject *pyObj) { - SbkEnumType* sbkType = reinterpret_cast(pyObj); + auto sbkType = reinterpret_cast(pyObj); PyObject_GC_UnTrack(pyObj); #ifndef Py_LIMITED_API @@ -324,13 +324,13 @@ void SbkEnumTypeDealloc(PyObject* pyObj) #endif } -PyObject* SbkEnumTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* kwds) +PyObject *SbkEnumTypeTpNew(PyTypeObject *metatype, PyObject *args, PyObject *kwds) { newfunc type_new = reinterpret_cast(PyType_GetSlot(&PyType_Type, Py_tp_new)); - SbkEnumType *newType = reinterpret_cast(type_new(metatype, args, kwds)); + auto newType = reinterpret_cast(type_new(metatype, args, kwds)); if (!newType) return 0; - return reinterpret_cast(newType); + return reinterpret_cast(newType); } } // extern "C" @@ -340,15 +340,15 @@ namespace Shiboken { class DeclaredEnumTypes { public: - DeclaredEnumTypes(const DeclaredEnumTypes&) = delete; - DeclaredEnumTypes(DeclaredEnumTypes&&) = delete; - DeclaredEnumTypes& operator=(const DeclaredEnumTypes&) = delete; - DeclaredEnumTypes& operator=(DeclaredEnumTypes&&) = delete; + DeclaredEnumTypes(const DeclaredEnumTypes &) = delete; + DeclaredEnumTypes(DeclaredEnumTypes &&) = delete; + DeclaredEnumTypes &operator=(const DeclaredEnumTypes &) = delete; + DeclaredEnumTypes &operator=(DeclaredEnumTypes &&) = delete; DeclaredEnumTypes(); ~DeclaredEnumTypes(); - static DeclaredEnumTypes& instance(); - void addEnumType(PyTypeObject* type); + static DeclaredEnumTypes &instance(); + void addEnumType(PyTypeObject *type); private: std::vector m_enumTypes; @@ -356,16 +356,16 @@ private: namespace Enum { -bool check(PyObject* pyObj) +bool check(PyObject *pyObj) { return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF(); } -PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue) +PyObject *getEnumItemFromValue(PyTypeObject *enumType, long itemValue) { PyObject *key, *value; Py_ssize_t pos = 0; - PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast("values")); + PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast("values")); while (PyDict_Next(values, &pos, &key, &value)) { SbkEnumObject *obj = reinterpret_cast(value); @@ -377,19 +377,19 @@ PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue) return 0; } -static PyTypeObject* createEnum(const char* fullName, const char* cppName, - const char* /* shortName */, - PyTypeObject* flagsType) +static PyTypeObject *createEnum(const char *fullName, const char *cppName, + const char */* shortName */, + PyTypeObject *flagsType) { - PyTypeObject* enumType = newTypeWithName(fullName, cppName, flagsType); + PyTypeObject *enumType = newTypeWithName(fullName, cppName, flagsType); if (PyType_Ready(enumType) < 0) return 0; return enumType; } -PyTypeObject* createGlobalEnum(PyObject* module, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType) +PyTypeObject *createGlobalEnum(PyObject *module, const char *name, const char *fullName, const char *cppName, PyTypeObject *flagsType) { - PyTypeObject* enumType = createEnum(fullName, cppName, name, flagsType); + PyTypeObject *enumType = createEnum(fullName, cppName, name, flagsType); if (enumType && PyModule_AddObject(module, name, reinterpret_cast(enumType)) < 0) return 0; if (flagsType && PyModule_AddObject(module, PepType_GetNameStr(flagsType), @@ -398,9 +398,9 @@ PyTypeObject* createGlobalEnum(PyObject* module, const char* name, const char* f return enumType; } -PyTypeObject* createScopedEnum(SbkObjectType* scope, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType) +PyTypeObject *createScopedEnum(SbkObjectType *scope, const char *name, const char *fullName, const char *cppName, PyTypeObject *flagsType) { - PyTypeObject* enumType = createEnum(fullName, cppName, name, flagsType); + PyTypeObject *enumType = createEnum(fullName, cppName, name, flagsType); if (enumType && PyDict_SetItemString(reinterpret_cast(scope)->tp_dict, name, reinterpret_cast(enumType)) < 0) return nullptr; @@ -411,18 +411,18 @@ PyTypeObject* createScopedEnum(SbkObjectType* scope, const char* name, const cha return enumType; } -static PyObject* createEnumItem(PyTypeObject* enumType, const char* itemName, long itemValue) +static PyObject *createEnumItem(PyTypeObject *enumType, const char *itemName, long itemValue) { - PyObject* enumItem = newItem(enumType, itemValue, itemName); + PyObject *enumItem = newItem(enumType, itemValue, itemName); if (PyDict_SetItemString(enumType->tp_dict, itemName, enumItem) < 0) return 0; Py_DECREF(enumItem); return enumItem; } -bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue) +bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module, const char *itemName, long itemValue) { - PyObject* enumItem = createEnumItem(enumType, itemName, itemValue); + PyObject *enumItem = createEnumItem(enumType, itemName, itemValue); if (enumItem) { if (PyModule_AddObject(module, itemName, enumItem) < 0) return false; @@ -449,7 +449,7 @@ bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope, return false; } -bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue) +bool createScopedEnumItem(PyTypeObject *enumType, SbkObjectType *scope, const char *itemName, long itemValue) { return createScopedEnumItem(enumType, reinterpret_cast(scope), itemName, itemValue); } @@ -458,12 +458,12 @@ PyObject * newItem(PyTypeObject *enumType, long itemValue, const char *itemName) { bool newValue = true; - SbkEnumObject* enumObj; + SbkEnumObject *enumObj; if (!itemName) { - enumObj = reinterpret_cast( + enumObj = reinterpret_cast( getEnumItemFromValue(enumType, itemValue)); if (enumObj) - return reinterpret_cast(enumObj); + return reinterpret_cast(enumObj); newValue = false; } @@ -476,16 +476,16 @@ newItem(PyTypeObject *enumType, long itemValue, const char *itemName) enumObj->ob_value = itemValue; if (newValue) { - PyObject* values = PyDict_GetItemString(enumType->tp_dict, const_cast("values")); + PyObject *values = PyDict_GetItemString(enumType->tp_dict, const_cast("values")); if (!values) { values = PyDict_New(); - PyDict_SetItemString(enumType->tp_dict, const_cast("values"), values); + PyDict_SetItemString(enumType->tp_dict, const_cast("values"), values); Py_DECREF(values); // ^ values still alive, because setitemstring incref it } - PyDict_SetItemString(values, itemName, reinterpret_cast(enumObj)); + PyDict_SetItemString(values, itemName, reinterpret_cast(enumObj)); } - return reinterpret_cast(enumObj); + return reinterpret_cast(enumObj); } static PyType_Slot SbkNewType_slots[] = { @@ -581,8 +581,8 @@ copyNumberMethods(PyTypeObject *flagsType, } PyTypeObject * -newTypeWithName(const char* name, - const char* cppName, +newTypeWithName(const char *name, + const char *cppName, PyTypeObject *numbers_fromFlag) { // Careful: PyType_FromSpec does not allocate the string. @@ -606,40 +606,40 @@ newTypeWithName(const char* name, Py_TYPE(type) = SbkEnumType_TypeF(); Py_INCREF(Py_TYPE(type)); - SbkEnumType* enumType = reinterpret_cast(type); + SbkEnumType *enumType = reinterpret_cast(type); PepType_SETP(enumType)->cppName = cppName; PepType_SETP(enumType)->converterPtr = &PepType_SETP(enumType)->converter; DeclaredEnumTypes::instance().addEnumType(type); return type; } -const char* getCppName(PyTypeObject* enumType) +const char *getCppName(PyTypeObject *enumType) { assert(Py_TYPE(enumType) == SbkEnumType_TypeF()); - return PepType_SETP(reinterpret_cast(enumType))->cppName; + return PepType_SETP(reinterpret_cast(enumType))->cppName; } -long int getValue(PyObject* enumItem) +long int getValue(PyObject *enumItem) { assert(Shiboken::Enum::check(enumItem)); - return reinterpret_cast(enumItem)->ob_value; + return reinterpret_cast(enumItem)->ob_value; } -void setTypeConverter(PyTypeObject* enumType, SbkConverter* converter) +void setTypeConverter(PyTypeObject *enumType, SbkConverter *converter) { - //reinterpret_cast(enumType)->converter = converter; + //reinterpret_cast(enumType)->converter = converter; *PepType_SGTP(enumType)->converter = converter; } -SbkConverter* getTypeConverter(PyTypeObject* enumType) +SbkConverter *getTypeConverter(PyTypeObject *enumType) { - //return reinterpret_cast(enumType)->converter; + //return reinterpret_cast(enumType)->converter; return *PepType_SGTP(enumType)->converter; } } // namespace Enum -DeclaredEnumTypes& DeclaredEnumTypes::instance() +DeclaredEnumTypes &DeclaredEnumTypes::instance() { static DeclaredEnumTypes me; return me; @@ -662,7 +662,7 @@ DeclaredEnumTypes::~DeclaredEnumTypes() m_enumTypes.clear(); } -void DeclaredEnumTypes::addEnumType(PyTypeObject* type) +void DeclaredEnumTypes::addEnumType(PyTypeObject *type) { m_enumTypes.push_back(type); } diff --git a/sources/shiboken2/libshiboken/sbkenum.h b/sources/shiboken2/libshiboken/sbkenum.h index c1ec7c4c1..199027836 100644 --- a/sources/shiboken2/libshiboken/sbkenum.h +++ b/sources/shiboken2/libshiboken/sbkenum.h @@ -57,14 +57,14 @@ struct SbkEnumTypePrivate; namespace Shiboken { -inline bool isShibokenEnum(PyObject* pyObj) +inline bool isShibokenEnum(PyObject *pyObj) { return Py_TYPE(Py_TYPE(pyObj)) == SbkEnumType_TypeF(); } namespace Enum { - LIBSHIBOKEN_API bool check(PyObject* obj); + LIBSHIBOKEN_API bool check(PyObject *obj); /** * Creates a new enum type (and its flags type, if any is given) * and registers it to Python and adds it to \p module. @@ -75,17 +75,17 @@ namespace Enum * \param flagsType Optional Python type for the flags associated with the enum. * \return The new enum type or NULL if it fails. */ - LIBSHIBOKEN_API PyTypeObject* createGlobalEnum(PyObject* module, - const char* name, - const char* fullName, - const char* cppName, - PyTypeObject* flagsType = 0); + LIBSHIBOKEN_API PyTypeObject *createGlobalEnum(PyObject *module, + const char *name, + const char *fullName, + const char *cppName, + PyTypeObject *flagsType = nullptr); /// This function does the same as createGlobalEnum, but adds the enum to a Shiboken type or namespace. - LIBSHIBOKEN_API PyTypeObject* createScopedEnum(SbkObjectType* scope, - const char* name, - const char* fullName, - const char* cppName, - PyTypeObject* flagsType = 0); + LIBSHIBOKEN_API PyTypeObject *createScopedEnum(SbkObjectType *scope, + const char *name, + const char *fullName, + const char *cppName, + PyTypeObject *flagsType = nullptr); /** * Creates a new enum item for a given enum type and adds it to \p module. @@ -95,25 +95,25 @@ namespace Enum * \param itemValue Numerical value of the enum item. * \return true if everything goes fine, false if it fails. */ - LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue); + LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject *enumType, PyObject *module, const char *itemName, long itemValue); /// This function does the same as createGlobalEnumItem, but adds the enum to a Shiboken type or namespace. LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject *enumType, PyTypeObject *scope, const char *itemName, long itemValue); - LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue); + LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject *enumType, SbkObjectType *scope, const char *itemName, long itemValue); - LIBSHIBOKEN_API PyObject* newItem(PyTypeObject* enumType, long itemValue, const char* itemName = 0); + LIBSHIBOKEN_API PyObject *newItem(PyTypeObject *enumType, long itemValue, const char *itemName = 0); - LIBSHIBOKEN_API PyTypeObject* newTypeWithName(const char* name, const char* cppName, + LIBSHIBOKEN_API PyTypeObject *newTypeWithName(const char *name, const char *cppName, PyTypeObject *numbers_fromFlag=nullptr); - LIBSHIBOKEN_API const char* getCppName(PyTypeObject* type); + LIBSHIBOKEN_API const char *getCppName(PyTypeObject *type); - LIBSHIBOKEN_API long getValue(PyObject* enumItem); - LIBSHIBOKEN_API PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue); + LIBSHIBOKEN_API long getValue(PyObject *enumItem); + LIBSHIBOKEN_API PyObject *getEnumItemFromValue(PyTypeObject *enumType, long itemValue); /// Sets the enum's type converter. - LIBSHIBOKEN_API void setTypeConverter(PyTypeObject* enumType, SbkConverter* converter); + LIBSHIBOKEN_API void setTypeConverter(PyTypeObject *enumType, SbkConverter *converter); /// Returns the converter assigned to the enum \p type. - LIBSHIBOKEN_API SbkConverter* getTypeConverter(PyTypeObject* enumType); + LIBSHIBOKEN_API SbkConverter *getTypeConverter(PyTypeObject *enumType); } } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/sbkmodule.cpp b/sources/shiboken2/libshiboken/sbkmodule.cpp index a29ec38c7..7bfbf51a8 100644 --- a/sources/shiboken2/libshiboken/sbkmodule.cpp +++ b/sources/shiboken2/libshiboken/sbkmodule.cpp @@ -57,10 +57,10 @@ namespace Shiboken namespace Module { -PyObject* import(const char* moduleName) +PyObject *import(const char *moduleName) { - PyObject* sysModules = PyImport_GetModuleDict(); - PyObject* module = PyDict_GetItemString(sysModules, moduleName); + PyObject *sysModules = PyImport_GetModuleDict(); + PyObject *module = PyDict_GetItemString(sysModules, moduleName); if (module) Py_INCREF(module); else @@ -72,37 +72,37 @@ PyObject* import(const char* moduleName) return module; } -PyObject* create(const char* moduleName, void* moduleData) +PyObject *create(const char *moduleName, void *moduleData) { Shiboken::init(); #ifndef IS_PY3K return Py_InitModule(moduleName, reinterpret_cast(moduleData)); #else - return PyModule_Create(reinterpret_cast(moduleData)); + return PyModule_Create(reinterpret_cast(moduleData)); #endif } -void registerTypes(PyObject* module, PyTypeObject** types) +void registerTypes(PyObject *module, PyTypeObject **types) { ModuleTypesMap::iterator iter = moduleTypes.find(module); if (iter == moduleTypes.end()) moduleTypes.insert(std::make_pair(module, types)); } -PyTypeObject** getTypes(PyObject* module) +PyTypeObject **getTypes(PyObject *module) { ModuleTypesMap::iterator iter = moduleTypes.find(module); return (iter == moduleTypes.end()) ? 0 : iter->second; } -void registerTypeConverters(PyObject* module, SbkConverter** converters) +void registerTypeConverters(PyObject *module, SbkConverter **converters) { ModuleConvertersMap::iterator iter = moduleConverters.find(module); if (iter == moduleConverters.end()) moduleConverters.insert(std::make_pair(module, converters)); } -SbkConverter** getTypeConverters(PyObject* module) +SbkConverter **getTypeConverters(PyObject *module) { ModuleConvertersMap::iterator iter = moduleConverters.find(module); return (iter == moduleConverters.end()) ? 0 : iter->second; diff --git a/sources/shiboken2/libshiboken/sbkmodule.h b/sources/shiboken2/libshiboken/sbkmodule.h index 659c41c4d..75eff5a79 100644 --- a/sources/shiboken2/libshiboken/sbkmodule.h +++ b/sources/shiboken2/libshiboken/sbkmodule.h @@ -46,7 +46,7 @@ #if PY_MAJOR_VERSION >= 3 #define SBK_MODULE_INIT_ERROR 0 #define SBK_MODULE_INIT_FUNCTION_BEGIN(ModuleName) \ - extern "C" SBK_EXPORT_MODULE PyObject* PyInit_##ModuleName() { + extern "C" SBK_EXPORT_MODULE PyObject *PyInit_##ModuleName() { #define SBK_MODULE_INIT_FUNCTION_END \ return module; } @@ -72,43 +72,43 @@ namespace Module { * If the module is already imported, it increments its reference count before returning it. * \returns the module specified in \p moduleName or NULL if an error occurs. */ -LIBSHIBOKEN_API PyObject* import(const char* moduleName); +LIBSHIBOKEN_API PyObject *import(const char *moduleName); /** * Creates a new Python module named \p moduleName using the information passed in \p moduleData. - * In fact, \p moduleData expects a "PyMethodDef*" object, but that's for Python 2. A void* + * In fact, \p moduleData expects a "PyMethodDef *" object, but that's for Python 2. A "void*" * was preferred to make this work with future Python 3 support. * \returns a newly created module. */ -LIBSHIBOKEN_API PyObject* create(const char* moduleName, void* moduleData); +LIBSHIBOKEN_API PyObject *create(const char *moduleName, void *moduleData); /** * Registers the list of types created by \p module. * \param module Module where the types were created. - * \param types Array of PyTypeObject* objects representing the types created on \p module. + * \param types Array of PyTypeObject *objects representing the types created on \p module. */ -LIBSHIBOKEN_API void registerTypes(PyObject* module, PyTypeObject** types); +LIBSHIBOKEN_API void registerTypes(PyObject *module, PyTypeObject **types); /** * Retrieves the array of types. * \param module Module where the types were created. - * \returns A pointer to the PyTypeObject* array of types. + * \returns A pointer to the PyTypeObject *array of types. */ -LIBSHIBOKEN_API PyTypeObject** getTypes(PyObject* module); +LIBSHIBOKEN_API PyTypeObject **getTypes(PyObject *module); /** * Registers the list of converters created by \p module for non-wrapper types. * \param module Module where the converters were created. - * \param converters Array of SbkConverter* objects representing the converters created on \p module. + * \param converters Array of SbkConverter *objects representing the converters created on \p module. */ -LIBSHIBOKEN_API void registerTypeConverters(PyObject* module, SbkConverter** converters); +LIBSHIBOKEN_API void registerTypeConverters(PyObject *module, SbkConverter **converters); /** * Retrieves the array of converters. * \param module Module where the converters were created. - * \returns A pointer to the SbkConverter* array of converters. + * \returns A pointer to the SbkConverter *array of converters. */ -LIBSHIBOKEN_API SbkConverter** getTypeConverters(PyObject* module); +LIBSHIBOKEN_API SbkConverter **getTypeConverters(PyObject *module); } } // namespace Shiboken::Module diff --git a/sources/shiboken2/libshiboken/sbkstring.cpp b/sources/shiboken2/libshiboken/sbkstring.cpp index a3ffcdabb..d3c337524 100644 --- a/sources/shiboken2/libshiboken/sbkstring.cpp +++ b/sources/shiboken2/libshiboken/sbkstring.cpp @@ -46,7 +46,7 @@ namespace Shiboken namespace String { -bool checkType(PyTypeObject* type) +bool checkType(PyTypeObject *type) { return type == &PyUnicode_Type #if PY_MAJOR_VERSION < 3 @@ -55,7 +55,7 @@ bool checkType(PyTypeObject* type) ; } -bool check(PyObject* obj) +bool check(PyObject *obj) { return obj == Py_None || #if PY_MAJOR_VERSION < 3 @@ -64,17 +64,17 @@ bool check(PyObject* obj) PyUnicode_Check(obj); } -bool checkChar(PyObject* pyobj) +bool checkChar(PyObject *pyobj) { return check(pyobj) && (len(pyobj) == 1); } -bool isConvertible(PyObject* obj) +bool isConvertible(PyObject *obj) { return check(obj); } -PyObject* fromCString(const char* value) +PyObject *fromCString(const char *value) { #ifdef IS_PY3K return PyUnicode_FromString(value); @@ -83,7 +83,7 @@ PyObject* fromCString(const char* value) #endif } -PyObject* fromCString(const char* value, int len) +PyObject *fromCString(const char *value, int len) { #ifdef IS_PY3K return PyUnicode_FromStringAndSize(value, len); @@ -92,13 +92,13 @@ PyObject* fromCString(const char* value, int len) #endif } -const char* toCString(PyObject* str, Py_ssize_t* len) +const char *toCString(PyObject *str, Py_ssize_t *len) { if (str == Py_None) return NULL; if (PyUnicode_Check(str)) { if (len) { - // We need to encode the unicode string into utf8 to know the size of returned char*. + // We need to encode the unicode string into utf8 to know the size of returned char *. Shiboken::AutoDecRef uniStr(PyUnicode_AsUTF8String(str)); *len = PyBytes_GET_SIZE(uniStr.object()); } @@ -122,10 +122,10 @@ const char* toCString(PyObject* str, Py_ssize_t* len) return 0; } -bool concat(PyObject** val1, PyObject* val2) +bool concat(PyObject **val1, PyObject *val2) { if (PyUnicode_Check(*val1) && PyUnicode_Check(val2)) { - PyObject* result = PyUnicode_Concat(*val1, val2); + PyObject *result = PyUnicode_Concat(*val1, val2); Py_DECREF(*val1); *val1 = result; return true; @@ -145,11 +145,11 @@ bool concat(PyObject** val1, PyObject* val2) return false; } -PyObject* fromFormat(const char* format, ...) +PyObject *fromFormat(const char *format, ...) { va_list argp; va_start(argp, format); - PyObject* result = 0; + PyObject *result = nullptr; #ifdef IS_PY3K result = PyUnicode_FromFormatV(format, argp); #else @@ -159,7 +159,7 @@ PyObject* fromFormat(const char* format, ...) return result; } -PyObject* fromStringAndSize(const char* str, Py_ssize_t size) +PyObject *fromStringAndSize(const char *str, Py_ssize_t size) { #ifdef IS_PY3K return PyUnicode_FromStringAndSize(str, size); @@ -168,15 +168,15 @@ PyObject* fromStringAndSize(const char* str, Py_ssize_t size) #endif } -int compare(PyObject* val1, const char* val2) +int compare(PyObject *val1, const char *val2) { if (PyUnicode_Check(val1)) #ifdef IS_PY3K return PyUnicode_CompareWithASCIIString(val1, val2); #else { - PyObject* uVal2 = PyUnicode_FromString(val2); - bool result = PyUnicode_Compare(val1, uVal2); + PyObject *uVal2 = PyUnicode_FromString(val2); + bool result = PyUnicode_Compare(val1, uVal2); Py_XDECREF(uVal2); return result; } @@ -187,7 +187,7 @@ int compare(PyObject* val1, const char* val2) } -Py_ssize_t len(PyObject* str) +Py_ssize_t len(PyObject *str) { if (str == Py_None) return 0; diff --git a/sources/shiboken2/libshiboken/sbkstring.h b/sources/shiboken2/libshiboken/sbkstring.h index a6b5fbeed..ec674ee7b 100644 --- a/sources/shiboken2/libshiboken/sbkstring.h +++ b/sources/shiboken2/libshiboken/sbkstring.h @@ -53,18 +53,18 @@ namespace Shiboken { namespace String { - LIBSHIBOKEN_API bool check(PyObject* obj); - LIBSHIBOKEN_API bool checkType(PyTypeObject* obj); - LIBSHIBOKEN_API bool checkChar(PyObject* obj); - LIBSHIBOKEN_API bool isConvertible(PyObject* obj); - LIBSHIBOKEN_API PyObject* fromCString(const char* value); - LIBSHIBOKEN_API PyObject* fromCString(const char* value, int len); - LIBSHIBOKEN_API const char* toCString(PyObject* str, Py_ssize_t* len = 0); - LIBSHIBOKEN_API bool concat(PyObject** val1, PyObject* val2); - LIBSHIBOKEN_API PyObject* fromFormat(const char* format, ...); - LIBSHIBOKEN_API PyObject* fromStringAndSize(const char* str, Py_ssize_t size); - LIBSHIBOKEN_API int compare(PyObject* val1, const char* val2); - LIBSHIBOKEN_API Py_ssize_t len(PyObject* str); + LIBSHIBOKEN_API bool check(PyObject *obj); + LIBSHIBOKEN_API bool checkType(PyTypeObject *obj); + LIBSHIBOKEN_API bool checkChar(PyObject *obj); + LIBSHIBOKEN_API bool isConvertible(PyObject *obj); + LIBSHIBOKEN_API PyObject *fromCString(const char *value); + LIBSHIBOKEN_API PyObject *fromCString(const char *value, int len); + LIBSHIBOKEN_API const char *toCString(PyObject *str, Py_ssize_t *len = 0); + LIBSHIBOKEN_API bool concat(PyObject **val1, PyObject *val2); + LIBSHIBOKEN_API PyObject *fromFormat(const char *format, ...); + LIBSHIBOKEN_API PyObject *fromStringAndSize(const char *str, Py_ssize_t size); + LIBSHIBOKEN_API int compare(PyObject *val1, const char *val2); + LIBSHIBOKEN_API Py_ssize_t len(PyObject *str); } // namespace String } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/shibokenbuffer.cpp b/sources/shiboken2/libshiboken/shibokenbuffer.cpp index a691a31ee..330470183 100644 --- a/sources/shiboken2/libshiboken/shibokenbuffer.cpp +++ b/sources/shiboken2/libshiboken/shibokenbuffer.cpp @@ -41,14 +41,14 @@ #include #include -bool Shiboken::Buffer::checkType(PyObject* pyObj) +bool Shiboken::Buffer::checkType(PyObject *pyObj) { return PyObject_CheckReadBuffer(pyObj) != 0; } -void* Shiboken::Buffer::getPointer(PyObject* pyObj, Py_ssize_t* size) +void *Shiboken::Buffer::getPointer(PyObject *pyObj, Py_ssize_t *size) { - const void* buffer = 0; + const void *buffer = nullptr; #ifdef IS_PY3K Py_buffer view; if (PyObject_GetBuffer(pyObj, &view, PyBUF_ND) == 0) { @@ -67,10 +67,10 @@ void* Shiboken::Buffer::getPointer(PyObject* pyObj, Py_ssize_t* size) if (size) *size = bufferSize; #endif - return const_cast(buffer); + return const_cast(buffer); } -PyObject* Shiboken::Buffer::newObject(void* memory, Py_ssize_t size, Type type) +PyObject *Shiboken::Buffer::newObject(void *memory, Py_ssize_t size, Type type) { if (size == 0) Py_RETURN_NONE; @@ -93,7 +93,7 @@ PyObject* Shiboken::Buffer::newObject(void* memory, Py_ssize_t size, Type type) #endif } -PyObject* Shiboken::Buffer::newObject(const void* memory, Py_ssize_t size) +PyObject *Shiboken::Buffer::newObject(const void *memory, Py_ssize_t size) { - return newObject(const_cast(memory), size, ReadOnly); + return newObject(const_cast(memory), size, ReadOnly); } diff --git a/sources/shiboken2/libshiboken/shibokenbuffer.h b/sources/shiboken2/libshiboken/shibokenbuffer.h index 04a5b6dd0..8c41dad6c 100644 --- a/sources/shiboken2/libshiboken/shibokenbuffer.h +++ b/sources/shiboken2/libshiboken/shibokenbuffer.h @@ -58,18 +58,18 @@ namespace Buffer * Creates a new Python buffer pointing to a contiguous memory block at * \p memory of size \p size. */ - LIBSHIBOKEN_API PyObject* newObject(void* memory, Py_ssize_t size, Type type); + LIBSHIBOKEN_API PyObject *newObject(void *memory, Py_ssize_t size, Type type); /** * Creates a new read only Python buffer pointing to a contiguous memory block at * \p memory of size \p size. */ - LIBSHIBOKEN_API PyObject* newObject(const void* memory, Py_ssize_t size); + LIBSHIBOKEN_API PyObject *newObject(const void *memory, Py_ssize_t size); /** * Check if is ok to use \p pyObj as argument in all function under Shiboken::Buffer namespace. */ - LIBSHIBOKEN_API bool checkType(PyObject* pyObj); + LIBSHIBOKEN_API bool checkType(PyObject *pyObj); /** * Returns a pointer to the memory pointed by the buffer \p pyObj, \p size is filled with the buffer @@ -77,7 +77,7 @@ namespace Buffer * * If the \p pyObj is a non-contiguous buffer a Python error is set. */ - LIBSHIBOKEN_API void* getPointer(PyObject* pyObj, Py_ssize_t* size = 0); + LIBSHIBOKEN_API void *getPointer(PyObject *pyObj, Py_ssize_t *size = 0); } // namespace Buffer } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/signature.cpp b/sources/shiboken2/libshiboken/signature.cpp index 8003f142a..8f9c5a459 100644 --- a/sources/shiboken2/libshiboken/signature.cpp +++ b/sources/shiboken2/libshiboken/signature.cpp @@ -831,7 +831,7 @@ void handler(int sig) { void *array[30]; size_t size; - // get void*'s for all entries on the stack + // get void *'s for all entries on the stack size = backtrace(array, 30); // print out all the frames to stderr @@ -1089,7 +1089,7 @@ _build_func_to_type(PyObject *obtype) || (check_name && PyObject_RichCompareBool(look, given, Py_EQ) != 1)) { PyErr_Clear(); Shiboken::AutoDecRef cfunc(PyCFunction_NewEx(meth, - reinterpret_cast(type), nullptr)); + reinterpret_cast(type), nullptr)); if (cfunc.isNull()) return -1; if (meth->ml_flags & METH_STATIC) diff --git a/sources/shiboken2/libshiboken/threadstatesaver.h b/sources/shiboken2/libshiboken/threadstatesaver.h index ddad9b67f..10b3af12b 100644 --- a/sources/shiboken2/libshiboken/threadstatesaver.h +++ b/sources/shiboken2/libshiboken/threadstatesaver.h @@ -49,17 +49,17 @@ namespace Shiboken class LIBSHIBOKEN_API ThreadStateSaver { public: - ThreadStateSaver(const ThreadStateSaver&) = delete; - ThreadStateSaver(ThreadStateSaver&&) = delete; - ThreadStateSaver &operator=(const ThreadStateSaver&) = delete; - ThreadStateSaver &operator=(ThreadStateSaver&&) = delete; + ThreadStateSaver(const ThreadStateSaver &) = delete; + ThreadStateSaver(ThreadStateSaver &&) = delete; + ThreadStateSaver &operator=(const ThreadStateSaver &) = delete; + ThreadStateSaver &operator=(ThreadStateSaver &&) = delete; ThreadStateSaver(); ~ThreadStateSaver(); void save(); void restore(); private: - PyThreadState* m_threadState; + PyThreadState *m_threadState; }; } // namespace Shiboken diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp index 8e351cedd..ab205e215 100644 --- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp +++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.cpp @@ -46,13 +46,13 @@ namespace Shiboken { namespace Conversions { -static SbkConverter* createConverterObject(PyTypeObject* type, +static SbkConverter *createConverterObject(PyTypeObject *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc) { - SbkConverter* converter = new SbkConverter; + SbkConverter *converter = new SbkConverter; converter->pythonType = type; converter->pointerToPython = pointerToPythonFunc; @@ -64,20 +64,20 @@ static SbkConverter* createConverterObject(PyTypeObject* type, return converter; } -SbkConverter* createConverter(SbkObjectType* type, +SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc) { - SbkConverter* converter = createConverterObject((PyTypeObject*)type, + SbkConverter *converter = createConverterObject(reinterpret_cast(type), toCppPointerConvFunc, toCppPointerCheckFunc, pointerToPythonFunc, copyToPythonFunc); type->d->converter = converter; return converter; } -void deleteConverter(SbkConverter* converter) +void deleteConverter(SbkConverter *converter) { if (converter) { converter->toCppConversions.clear(); @@ -85,44 +85,44 @@ void deleteConverter(SbkConverter* converter) } } -void addPythonToCppValueConversion(SbkConverter* converter, +void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { converter->toCppConversions.push_back(std::make_pair(isConvertibleToCppFunc, pythonToCppFunc)); } -void addPythonToCppValueConversion(SbkObjectType* type, +void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc) { addPythonToCppValueConversion(type->d->converter, pythonToCppFunc, isConvertibleToCppFunc); } -PyObject* pointerToPython(SbkObjectType* type, const void* cppIn) +PyObject *pointerToPython(SbkObjectType *type, const void *cppIn) { if (!cppIn) Py_RETURN_NONE; return type->d->converter->pointerToPython(cppIn); } -static inline PyObject* CopyCppToPython(SbkConverter* converter, const void* cppIn) +static inline PyObject *CopyCppToPython(SbkConverter *converter, const void *cppIn) { assert(cppIn); return converter->copyToPython(cppIn); } -PyObject* copyToPython(SbkObjectType* type, const void* cppIn) +PyObject *copyToPython(SbkObjectType *type, const void *cppIn) { return CopyCppToPython(type->d->converter, cppIn); } -PyObject* toPython(SbkConverter* converter, const void* cppIn) +PyObject *toPython(SbkConverter *converter, const void *cppIn) { return CopyCppToPython(converter, cppIn); } -PyObject* referenceToPython(SbkObjectType* type, const void* cppIn) +PyObject *referenceToPython(SbkObjectType *type, const void *cppIn) { assert(cppIn); - PyObject* pyOut = (PyObject*)BindingManager::instance().retrieveWrapper(cppIn); + PyObject *pyOut = (PyObject *)BindingManager::instance().retrieveWrapper(cppIn); if (pyOut) { Py_INCREF(pyOut); return pyOut; @@ -134,16 +134,16 @@ PyObject* referenceToPython(SbkObjectType* type, const void* cppIn) return type->d->converter->pointerToPython(cppIn); } -PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn) { assert(pyIn); return type->d->converter->toCppPointerConversion.first(pyIn); } -static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn) +static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn) { assert(pyIn); - ToCppConversionList& convs = converter->toCppConversions; + ToCppConversionList &convs = converter->toCppConversions; for (ToCppConversionList::iterator conv = convs.begin(); conv != convs.end(); ++conv) { PythonToCppFunc toCppFunc = 0; if ((toCppFunc = (*conv).first(pyIn))) @@ -151,16 +151,16 @@ static inline PythonToCppFunc IsPythonToCppConvertible(SbkConverter* converter, } return 0; } -PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn) { return IsPythonToCppConvertible(type->d->converter, pyIn); } -PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn) +PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn) { return IsPythonToCppConvertible(converter, pyIn); } -PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn) +PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn) { if (pyIn != Py_None) { PythonToCppFunc toCpp = isPythonToCppPointerConvertible(type, pyIn); @@ -170,24 +170,27 @@ PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* return isPythonToCppValueConvertible(type, pyIn); } -void nonePythonToCppNullPtr(PyObject*, void* cppOut) +void nonePythonToCppNullPtr(PyObject *, void *cppOut) { assert(cppOut); - *((void**)cppOut) = 0; + *reinterpret_cast(cppOut) = nullptr; } -void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut) +void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut) { assert(pyIn); assert(cppOut); - SbkObjectType* inType = (SbkObjectType*)Py_TYPE(pyIn); - if (ObjectType::hasCast(inType)) - *((void**)cppOut) = ObjectType::cast(inType, (SbkObject*)pyIn, (PyTypeObject*)type); - else - *((void**)cppOut) = Object::cppPointer((SbkObject*)pyIn, (PyTypeObject*)type); + SbkObjectType *inType = (SbkObjectType *)Py_TYPE(pyIn); + if (ObjectType::hasCast(inType)) { + *reinterpret_cast(cppOut) = + ObjectType::cast(inType, reinterpret_cast(pyIn), reinterpret_cast(type)); + } else { + *reinterpret_cast(cppOut) = + Object::cppPointer(reinterpret_cast(pyIn), reinterpret_cast(type)); + } } -bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCppFunc) +bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCppFunc) { // This is the Object Type or Value Type conversion that only // retrieves the C++ pointer held in the Python wrapper. diff --git a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h index cc9ea7a19..3578e4039 100644 --- a/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h +++ b/sources/shiboken2/libshiboken/tmp-referencetopython/sbkconverter.h @@ -64,7 +64,7 @@ struct SbkConverter; * * C++ -> Python */ -typedef PyObject* (*CppToPythonFunc)(const void*); +typedef PyObject *(*CppToPythonFunc)(const void *); /** * This function converts a Python object to a C++ value, it may be @@ -77,7 +77,7 @@ typedef PyObject* (*CppToPythonFunc)(const void*); * * Python -> C++ */ -typedef void (*PythonToCppFunc)(PyObject*,void*); +typedef void (*PythonToCppFunc)(PyObject *,void *); /** * Checks if the Python object passed in the argument is convertible to a @@ -88,7 +88,7 @@ typedef void (*PythonToCppFunc)(PyObject*,void*); * * Python -> C++ ? */ -typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject*); +typedef PythonToCppFunc (*IsConvertibleToCppFunc)(PyObject *); } // extern "C" @@ -105,22 +105,22 @@ namespace Conversions { * \param copyToPythonFunc Function to convert a C++ object to a Python \p type, copying the object. * \returns The new converter referred by the wrapper \p type. */ -LIBSHIBOKEN_API SbkConverter* createConverter(SbkObjectType* type, +LIBSHIBOKEN_API SbkConverter *createConverter(SbkObjectType *type, PythonToCppFunc toCppPointerConvFunc, IsConvertibleToCppFunc toCppPointerCheckFunc, CppToPythonFunc pointerToPythonFunc, CppToPythonFunc copyToPythonFunc = 0); -LIBSHIBOKEN_API void deleteConverter(SbkConverter* converter); +LIBSHIBOKEN_API void deleteConverter(SbkConverter *converter); /** * Adds a new conversion of a Python object to a C++ value. * This is used in copy and implicit conversions. */ -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter* converter, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkConverter *converter, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); -LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, +LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType *type, PythonToCppFunc pythonToCppFunc, IsConvertibleToCppFunc isConvertibleToCppFunc); @@ -130,19 +130,19 @@ LIBSHIBOKEN_API void addPythonToCppValueConversion(SbkObjectType* type, * Retrieves the Python wrapper object for the given \p cppIn C++ pointer object. * This function is used only for Value and Object Types. * Example usage: - * TYPE* var; - * PyObject* pyVar = pointerToPython(SBKTYPE, &var); + * TYPE *var; + * PyObject *pyVar = pointerToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* pointerToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *pointerToPython(SbkObjectType *type, const void *cppIn); /** * Retrieves the Python wrapper object for the given C++ value pointed by \p cppIn. * This function is used only for Value Types. * Example usage: * TYPE var; - * PyObject* pyVar = copyToPython(SBKTYPE, &var); + * PyObject *pyVar = copyToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *copyToPython(SbkObjectType *type, const void *cppIn); // TODO:WRITEDOCSTRING - used only for Value Types - cppIn must point to a value /** @@ -150,41 +150,41 @@ LIBSHIBOKEN_API PyObject* copyToPython(SbkObjectType* type, const void* cppIn); * This function is used only for Value and Object Types. * It differs from pointerToPython() for not checking for a NULL pointer. * Example usage: - * TYPE& var = SOMETHING; - * PyObject* pyVar = copyToPython(SBKTYPE, &var); + * TYPE &var = SOMETHING; + * PyObject *pyVar = copyToPython(SBKTYPE, &var); */ -LIBSHIBOKEN_API PyObject* referenceToPython(SbkObjectType* type, const void* cppIn); +LIBSHIBOKEN_API PyObject *referenceToPython(SbkObjectType *type, const void *cppIn); // TODO:WRITEDOCSTRING - used only for Primitives and Containers (and Value Types) - cppIn must point to a primitive, container or value type /// This is the same as copyToPython function. -LIBSHIBOKEN_API PyObject* toPython(SbkConverter* converter, const void* cppIn); +LIBSHIBOKEN_API PyObject *toPython(SbkConverter *converter, const void *cppIn); // Python -> C++ convertibility checks ----------------------------------------------------- // TODO:WRITEDOCSTRING -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppPointerConvertible(SbkObjectType *type, PyObject *pyIn); // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppValueConvertible(SbkObjectType *type, PyObject *pyIn); // TODO:WRITEDOCSTRING- Returns a Python to C++ conversion function if true, or NULL if false. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType* type, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppReferenceConvertible(SbkObjectType *type, PyObject *pyIn); /// This is the same as isPythonToCppValueConvertible function. -LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter* converter, PyObject* pyIn); +LIBSHIBOKEN_API PythonToCppFunc isPythonToCppConvertible(SbkConverter *converter, PyObject *pyIn); // Python -> C++ --------------------------------------------------------------------------- // TODO:WRITEDOCSTRING - function used by the generated [TYPE]_PythonToCpp_[TYPE]_PTR -LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType* type, PyObject* pyIn, void* cppOut); +LIBSHIBOKEN_API void pythonToCppPointer(SbkObjectType *type, PyObject *pyIn, void *cppOut); // TODO:WRITEDOCSTRING - function used by the generated isConvertible when the PyObject is None, // making a C++ NULL pointer the result of the toCpp function call. // DRAFT: When the Python object is a Py_None, it's C++ conversion is always a NULL pointer. -LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject*, void* cppOut); +LIBSHIBOKEN_API void nonePythonToCppNullPtr(PyObject *, void *cppOut); // TODO:WRITEDOCSTRING - tells if \p toCpp is an implicit conversion. -LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType* type, PythonToCppFunc toCpp); +LIBSHIBOKEN_API bool isImplicitConversion(SbkObjectType *type, PythonToCppFunc toCpp); } } // namespace Shiboken::Conversions diff --git a/sources/shiboken2/libshiboken/typespec.cpp b/sources/shiboken2/libshiboken/typespec.cpp index a67daf12d..6dc5b00bc 100644 --- a/sources/shiboken2/libshiboken/typespec.cpp +++ b/sources/shiboken2/libshiboken/typespec.cpp @@ -599,17 +599,16 @@ offsetof(PyHeapTypeObject, as_sequence.sq_slice), PyObject * PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases) { - PyHeapTypeObject *res = (PyHeapTypeObject*)PyType_GenericAlloc(&PyType_Type, 0); + auto res = reinterpret_cast(PyType_GenericAlloc(&PyType_Type, 0)); PyTypeObject *type, *base; PyObject *modname; - char *s; - char *res_start = (char*)res; + auto res_start = reinterpret_cast(res); PyType_Slot *slot; /* Set the type name and qualname */ - s = (char *)strrchr(spec->name, '.'); // C++11 + auto s = const_cast(strrchr(spec->name, '.')); // C++11 if (s == NULL) - s = (char*)spec->name; + s = const_cast(spec->name); else s++; @@ -686,7 +685,7 @@ PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases) if (slot->slot == Py_tp_base || slot->slot == Py_tp_bases) /* Processed above */ continue; - *(void**)(res_start + slotoffsets[slot->slot]) = slot->pfunc; + *reinterpret_cast(res_start + slotoffsets[slot->slot]) = slot->pfunc; /* need to make a copy of the docstring slot, which usually points to a static string literal */ @@ -746,7 +745,7 @@ PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases) goto fail; } - return (PyObject*)res; + return reinterpret_cast(res); fail: Py_DECREF(res); @@ -770,7 +769,7 @@ PyType_GetSlot(PyTypeObject *type, int slot) /* Extension module requesting slot from a future version */ return NULL; } - return *(void**)(((char*)type) + slotoffsets[slot]); + return *reinterpret_cast(reinterpret_cast(type) + slotoffsets[slot]); } } // extern "C" diff --git a/sources/shiboken2/libshiboken/typespec.h b/sources/shiboken2/libshiboken/typespec.h index 81227acac..193b654c2 100644 --- a/sources/shiboken2/libshiboken/typespec.h +++ b/sources/shiboken2/libshiboken/typespec.h @@ -53,19 +53,19 @@ typedef struct{ } PyType_Slot; typedef struct{ - const char* name; + const char *name; int basicsize; int itemsize; unsigned int flags; PyType_Slot *slots; /* terminated by slot==0. */ } PyType_Spec; -LIBSHIBOKEN_API PyObject *PyType_FromSpec(PyType_Spec*); +LIBSHIBOKEN_API PyObject *PyType_FromSpec(PyType_Spec *); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 -LIBSHIBOKEN_API PyObject *PyType_FromSpecWithBases(PyType_Spec*, PyObject*); +LIBSHIBOKEN_API PyObject *PyType_FromSpecWithBases(PyType_Spec *, PyObject *); #endif #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 -LIBSHIBOKEN_API void* PyType_GetSlot(PyTypeObject*, int); +LIBSHIBOKEN_API void *PyType_GetSlot(PyTypeObject *, int); #endif // from typeslots.h diff --git a/sources/shiboken2/libshiboken/voidptr.cpp b/sources/shiboken2/libshiboken/voidptr.cpp index 5b0cb84ea..4d09adb0c 100644 --- a/sources/shiboken2/libshiboken/voidptr.cpp +++ b/sources/shiboken2/libshiboken/voidptr.cpp @@ -189,7 +189,7 @@ PyObject *toBytes(PyObject *self, PyObject *args) PyErr_SetString(PyExc_IndexError, "VoidPtr does not have a size set."); return nullptr; } - PyObject *bytes = PyBytes_FromStringAndSize(reinterpret_cast(sbkObject->cptr), + PyObject *bytes = PyBytes_FromStringAndSize(reinterpret_cast(sbkObject->cptr), sbkObject->size); Py_XINCREF(bytes); return bytes; @@ -290,17 +290,17 @@ static int SbkVoidPtrObject_getbuffer(PyObject *obj, Py_buffer *view, int flags) #if PY_VERSION_HEX < 0x03000000 -static Py_ssize_t SbkVoidPtrObject_readbufferproc(PyObject* self, Py_ssize_t segment, void** ptrptr) +static Py_ssize_t SbkVoidPtrObject_readbufferproc(PyObject *self, Py_ssize_t segment, void **ptrptr) { if (segment || !Shiboken::Object::isValid(self)) return -1; SbkVoidPtrObject *sbkObject = reinterpret_cast(self); - *ptrptr = reinterpret_cast(sbkObject->cptr); + *ptrptr = reinterpret_cast(sbkObject->cptr); return sbkObject->size; } -static Py_ssize_t SbkVoidPtrObject_segcountproc(PyObject* self, Py_ssize_t* lenp) +static Py_ssize_t SbkVoidPtrObject_segcountproc(PyObject *self, Py_ssize_t *lenp) { if (lenp) { SbkVoidPtrObject *sbkObject = reinterpret_cast(self); -- cgit v1.2.3