Fix reference/memory leaks

Author: gregor-anich-uibk

src/PythonQt.cpp

@@ -379,18 +379,23 @@ PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
 PythonQt::~PythonQt() {
   delete _p;
   _p = NULL;
+
+  Py_DECREF(&PythonQtSlotFunction_Type);
+  Py_DECREF(&PythonQtSignalFunction_Type);
+  Py_DECREF(&PythonQtSlotDecorator_Type);
+  Py_DECREF(&PythonQtProperty_Type);
+  Py_DECREF(&PythonQtBoolResult_Type);
+  Py_DECREF(&PythonQtClassWrapper_Type);
+  Py_DECREF(&PythonQtInstanceWrapper_Type);
+  Py_DECREF(&PythonQtStdOutRedirectType);
+  Py_DECREF(&PythonQtStdInRedirectType);
 }
 
 PythonQtPrivate::~PythonQtPrivate() {
   delete _defaultImporter;
   _defaultImporter = NULL;
 
-  {
-    QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);
-    while (i.hasNext()) {
-      delete i.next().value();
-    }
-  }
+  qDeleteAll(_knownClassInfos);
 
   PythonQtMethodInfo::cleanupCachedMethodInfos();
   PythonQtArgumentFrame::cleanupFreeList();
@@ -409,7 +414,9 @@ void PythonQt::setRedirectStdInCallback(PythonQtInputChangedCB* callback, void *
 
   // Backup original 'sys.stdin' if not yet done
   if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") ) {
-    PyObject_SetAttrString(sys.object(), "pythonqt_original_stdin", PyObject_GetAttrString(sys.object(), "stdin"));
+    PyObject *stdin = PyObject_GetAttrString(sys.object(), "stdin");
+    PyObject_SetAttrString(sys.object(), "pythonqt_original_stdin", stdin);
+    Py_XDECREF(stdin);
   }
 
   in = PythonQtStdInRedirectType.tp_new(&PythonQtStdInRedirectType, NULL, NULL);
@@ -428,15 +435,19 @@ void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)
   PythonQtObjectPtr sys;
   sys.setNewRef(PyImport_ImportModule("sys"));
 
+  PythonQtObjectPtr stdin;
   if (enabled) {
-    if( !PyObject_HasAttrString(sys.object(), "pythonqt_stdin") ) {
-      PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_stdin"));
+    if( PyObject_HasAttrString(sys.object(), "pythonqt_stdin") ) {
+      stdin.setNewRef(PyObject_GetAttrString(sys.object(), "pythonqt_stdin"));
     }
   } else {
-    if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") ) {
-      PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_original_stdin"));
+    if( PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") ) {
+      stdin.setNewRef(PyObject_GetAttrString(sys.object(), "pythonqt_original_stdin"));
     }
   }
+  if (stdin) {
+    PyObject_SetAttrString(sys.object(), "stdin", stdin);
+  }
 }
 
 PythonQtImportFileInterface* PythonQt::importInterface()
@@ -448,7 +459,7 @@ void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
 {
   if (_self->_p->_noLongerWrappedCB) {
     (*_self->_p->_noLongerWrappedCB)(o);
-  };
+  }
 }
 
 void PythonQt::setQObjectMissingAttributeCallback(PythonQtQObjectMissingAttributeCB* cb)
@@ -525,6 +536,7 @@ void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const
     PythonQtClassInfo* outerClassInfo = lookupClassInfoAndCreateIfNotPresent(outerClass);
     outerClassInfo->addNestedClass(info);
   } else {
+    Py_INCREF(pyobj);
     PyModule_AddObject(pack, info->className(), pyobj);
   }
   if (!module && package && strncmp(package, "Qt", 2) == 0) {
@@ -534,6 +546,7 @@ void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const
     PyModule_AddObject(packageByName("Qt"), info->className(), pyobj);
   }
   info->setPythonQtClassWrapper(pyobj);
+  Py_DECREF(pyobj);
 }
 
 PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
@@ -548,6 +561,7 @@ PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
     // address, so probably that C++ wrapper has been deleted earlier and
     // now we see a QObject with the same address.
     // Do not use the old wrapper anymore.
+    removeWrapperPointer(obj);
     wrap = NULL;
   }
   if (!wrap) {
@@ -733,6 +747,7 @@ PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtCla
   PyObject* typeDict = PyDict_New();
   PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
   PyDict_SetItemString(typeDict, "__module__", moduleName);
+  Py_DECREF(moduleName);
 
   PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
 
@@ -769,6 +784,7 @@ PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, Py
   PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
   PyObject* typeDict = PyDict_New();
   PyDict_SetItemString(typeDict, "__module__", module);
+  Py_DECREF(module);
 
   PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
 
@@ -893,17 +909,21 @@ QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
   QVariant result;
   clearError();
   if (pycode) {
-    PyObject* dict = NULL;
-    PyObject* globals = NULL;
+    PythonQtObjectPtr dict;
+    PythonQtObjectPtr globals;
     if (PyModule_Check(object)) {
       dict = PyModule_GetDict(object);
       globals = dict;
     } else if (PyDict_Check(object)) {
       dict = object;
       globals = dict;
     } else {
-      dict = PyObject_GetAttrString(object, "__dict__");
-      globals = PyObject_GetAttrString(PyImport_ImportModule(PyString_AS_STRING(PyObject_GetAttrString(object, "__module__"))),"__dict__");
+      PyObject *moduleName = PyObject_GetAttrString(object, "__module__");
+      PyObject *module = PyImport_ImportModule(PyString_AS_STRING(moduleName));
+      dict.setNewRef(PyObject_GetAttrString(object, "__dict__"));
+      globals.setNewRef(PyObject_GetAttrString(module, "__dict__"));
+      Py_XDECREF(moduleName);
+      Py_XDECREF(module);
     }
     PyObject* r = NULL;
     if (dict) {
@@ -1048,24 +1068,30 @@ PythonQtObjectPtr PythonQt::createUniqueModule()
 
 void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)
 {
+  PyObject *wrappedObject = _p->wrapQObject(qObject);
   if (PyModule_Check(object)) {
-    PyModule_AddObject(object, QStringToPythonCharPointer(name), _p->wrapQObject(qObject));
+    Py_XINCREF(wrappedObject);
+    PyModule_AddObject(object, QStringToPythonCharPointer(name), wrappedObject);
   } else if (PyDict_Check(object)) {
-    PyDict_SetItemString(object, QStringToPythonCharPointer(name), _p->wrapQObject(qObject));
+    PyDict_SetItemString(object, QStringToPythonCharPointer(name), wrappedObject);
   } else {
-    PyObject_SetAttrString(object, QStringToPythonCharPointer(name), _p->wrapQObject(qObject));
+    PyObject_SetAttrString(object, QStringToPythonCharPointer(name), wrappedObject);
   }
+  Py_XDECREF(wrappedObject);
 }
 
 void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)
 {
+  PyObject *value = PythonQtConv::QVariantToPyObject(v);
   if (PyModule_Check(object)) {
-    PyModule_AddObject(object, QStringToPythonCharPointer(name), PythonQtConv::QVariantToPyObject(v));
+    Py_XINCREF(value);
+    PyModule_AddObject(object, QStringToPythonCharPointer(name), value);
   } else if (PyDict_Check(object)) {
-    PyDict_SetItemString(object, QStringToPythonCharPointer(name), PythonQtConv::QVariantToPyObject(v));
+    PyDict_SetItemString(object, QStringToPythonCharPointer(name), value);
   } else {
-    PyObject_SetAttrString(object, QStringToPythonCharPointer(name), PythonQtConv::QVariantToPyObject(v));
+    PyObject_SetAttrString(object, QStringToPythonCharPointer(name), value);
   }
+  Py_XDECREF(value);
 }
 
 void PythonQt::removeVariable(PyObject* object, const QString& name)
@@ -1107,7 +1133,7 @@ QStringList PythonQt::introspection(PyObject* module, const QString& objectname,
   } else {
     object = lookupObject(module, objectname);
     if (!object && type == CallOverloads) {
-      PyObject* dict = lookupObject(module, "__builtins__");
+      PythonQtObjectPtr dict = lookupObject(module, "__builtins__");
       if (dict) {
         object = PyDict_GetItemString(dict, QStringToPythonCharPointer(objectname));
       }
@@ -1159,36 +1185,33 @@ QStringList PythonQt::introspectObject(PyObject* object, ObjectType type)
       }
     }
   } else {
-    PyObject* keys = NULL;
+    PythonQtObjectPtr keys;
     bool isDict = false;
     if (PyDict_Check(object)) {
-      keys = PyDict_Keys(object);
+      keys.setNewRef(PyDict_Keys(object));
       isDict = true;
     } else {
 #if defined(MEVISLAB) && !defined(PY3K)
       int oldPy3kWarningFlag = Py_Py3kWarningFlag;
       Py_Py3kWarningFlag = 0;  // temporarily disable Python 3 warnings
-      keys = PyObject_Dir(object);
+      keys.setNewRef(PyObject_Dir(object));
       Py_Py3kWarningFlag = oldPy3kWarningFlag;
 #else
-      keys = PyObject_Dir(object);
+      keys.setNewRef(PyObject_Dir(object));
 #endif
     }
     if (keys) {
       int count = PyList_Size(keys);
-      PyObject* key;
-      PyObject* value;
-      QString keystr;
       for (int i = 0;i<count;i++) {
-        key = PyList_GetItem(keys,i);
+        PythonQtObjectPtr key = PyList_GetItem(keys,i);
+        PythonQtObjectPtr value;
         if (isDict) {
           value = PyDict_GetItem(object, key);
-          Py_INCREF(value);
         } else {
-          value = PyObject_GetAttr(object, key);
+          value.setNewRef(PyObject_GetAttr(object, key));
         }
         if (!value) continue;
-        keystr = PyString_AsString(key);
+        QString keystr = PyString_AsString(key);
         static const QString underscoreStr("__tmp");
         if (!keystr.startsWith(underscoreStr)) {
           switch (type) {
@@ -1233,9 +1256,7 @@ QStringList PythonQt::introspectObject(PyObject* object, ObjectType type)
             std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
           }
         }
-        Py_DECREF(value);
       }
-      Py_DECREF(keys);
     }
   }
   PyErr_Clear();
@@ -1288,6 +1309,7 @@ QStringList PythonQt::introspectType(const QString& typeName, ObjectType type)
     PyObject* typeObject = getObjectByType(typeName);
     if (typeObject) {
       object = PyObject_GetAttrString(typeObject, QStringToPythonCharPointer(memberName));
+      Py_DECREF(typeObject);
     }
   }
   if (object) {
@@ -1359,6 +1381,7 @@ PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList
           PyObject* arg = PythonQtConv::QVariantToPyObject(it.value());
           if (arg) {
             PyDict_SetItemString(pkwargs, QStringToPythonCharPointer(it.key()), arg);
+            Py_DECREF(arg);
           } else {
             err = true;
             break;
@@ -1750,7 +1773,7 @@ void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQ
   }
 #ifdef PY3K
   PythonQtModuleDef.m_name = name.constData();
-  _p->_pythonQtModule = PyModule_Create(&PythonQtModuleDef);
+  _p->_pythonQtModule.setNewRef(PyModule_Create(&PythonQtModuleDef));
 #else
   _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
 #endif
@@ -1790,7 +1813,11 @@ void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQ
   Py_XDECREF(old_module_names);
 
 #ifdef PY3K
-  PyDict_SetItem(PyObject_GetAttrString(sys.object(), "modules"), PyUnicode_FromString(name.constData()), _p->_pythonQtModule.object());
+  PyObject *modules = PyObject_GetAttrString(sys.object(), "modules");
+  PyObject *nameObj = PyUnicode_FromString(name.constData());
+  PyDict_SetItem(modules, nameObj, _p->_pythonQtModule.object());
+  Py_XDECREF(modules);
+  Py_XDECREF(nameObj);
 #endif
 }
 
@@ -1810,7 +1837,8 @@ QString PythonQt::getReturnTypeOfWrappedMethod(PyObject* module, const QString&
 
 QString PythonQt::getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName)
 {
-  PythonQtObjectPtr typeObject = getObjectByType(typeName);
+  PythonQtObjectPtr typeObject;
+  typeObject.setNewRef(getObjectByType(typeName));
   if (typeObject.isNull()) {
     return "";
   }
@@ -2105,10 +2133,12 @@ const QMetaObject* PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper*
   builder.setClassName(((PyTypeObject*)type)->tp_name);
 
   PyObject* dict = ((PyTypeObject*)type)->tp_dict;
-  Py_ssize_t pos = NULL;
+  Py_ssize_t pos = 0;
   PyObject* value = NULL;
   PyObject* key = NULL;
-  static PyObject* qtSlots = PyString_FromString("_qtSlots");
+  static PyObject* qtSlots = NULL;
+  if (!qtSlots)
+      qtSlots = PyString_FromString("_qtSlots");
 
   bool needsMetaObject = false;
   // Iterate over all members and check if they affect the QMetaObject:
@@ -2126,7 +2156,7 @@ const QMetaObject* PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper*
       }
     }
   }
-  pos = NULL;
+  pos = 0;
   value = NULL;
   key = NULL;
   // Now look for slots: (this is a bug in QMetaObjectBuilder, all signals need to be added first)
@@ -2160,10 +2190,11 @@ const QMetaObject* PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper*
     }
     if (PyFunction_Check(value) && PyObject_HasAttr(value, qtSlots)) {
       // A function which has a "_qtSlots" signature list, add the slots to the meta object
-      PyObject* signatures = PyObject_GetAttr(value, qtSlots);
+      PythonQtObjectPtr signatures;
+      signatures.setNewRef(PyObject_GetAttr(value, qtSlots));
       Py_ssize_t count = PyList_Size(signatures);
       for (Py_ssize_t i = 0; i < count; i++) {
-        PyObject* signature = PyList_GET_ITEM(signatures, i);
+        PyObject* signature = PyList_GET_ITEM(signatures.object(), i);
         QByteArray sig = PyString_AsString(signature);
         // Split the return type and the rest of the signature,
         // no spaces should be in the rest of the signature...
@@ -2209,9 +2240,11 @@ int PythonQtPrivate::handleMetaCall(QObject* object, PythonQtInstanceWrapper* wr
     }
     PythonQtProperty* prop = NULL;
     // Get directly from the Python class, since we don't want to get the value of the property
-    PyObject* maybeProp = PyBaseObject_Type.tp_getattro((PyObject*)wrapper, PyString_FromString(metaProp.name()));
+    PythonQtObjectPtr name, maybeProp;
+    name.setNewRef(PyString_FromString(metaProp.name()));
+    maybeProp.setNewRef(PyBaseObject_Type.tp_getattro((PyObject*)wrapper, name));
     if (maybeProp && PythonQtProperty_Check(maybeProp)) {
-      prop = (PythonQtProperty*)maybeProp;
+      prop = (PythonQtProperty*)maybeProp.object();
     } else {
       return id - methodCount;
     }
@@ -2228,7 +2261,7 @@ int PythonQtPrivate::handleMetaCall(QObject* object, PythonQtInstanceWrapper* wr
 
       PyObject* value = prop->data->callGetter((PyObject*)wrapper);
       if (value) {
-        void* result = PythonQtConv::ConvertPythonToQt(info, value, false, NULL, args[0]);
+        void* result = PythonQtConv::ConvertPythonToQt(info, value, false, NULL, args[0]); // FIXME: what happens with result? free?
         Py_DECREF(value);
         return (result == NULL ? -1 : 0);
       } else {
@@ -2267,17 +2300,15 @@ QString PythonQtPrivate::getSignature(PyObject* object)
     PyMethodObject* method = NULL;
     PyFunctionObject* func = NULL;
 
-    bool decrefMethod = false;
-    
     if (PythonQtUtils::isPythonClassType(object)) {
       method = (PyMethodObject*)PyObject_GetAttrString(object, "__init__");
-      decrefMethod = true;
     } else if (object->ob_type == &PyFunction_Type) {
       func = (PyFunctionObject*)object;
     } else if (object->ob_type == &PyMethod_Type) {
       method = (PyMethodObject*)object;
+      Py_XINCREF(method);
     }
-    if (method)  {
+    if (method) {
       if (PyFunction_Check(method->im_func)) {
         func = (PyFunctionObject*)method->im_func;
       } else if (isMethodDescriptor((PyObject*)method)) {
@@ -2384,9 +2415,7 @@ QString PythonQtPrivate::getSignature(PyObject* object)
       signature = funcName + "(" + signature + ")";
     }
 
-    if (method && decrefMethod) {
-      Py_DECREF(method);
-    }
+    Py_XDECREF(method);
   }
 
   return signature;
@@ -2451,7 +2480,7 @@ PythonQtClassInfo* PythonQtPrivate::getClassInfo( const QByteArray& className )
       if (_knownLazyClasses.contains(className)) {
         QByteArray module = _knownLazyClasses.value(className);
         recursion = true;
-        PyImport_ImportModule(module);
+        PyImport_ImportModule(module); // FIXME: reference leaked
         recursion = false;
         result = _knownClassInfos.value(className);
         if (!result) {

src/PythonQt.h

@@ -813,7 +813,7 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
 
   //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
-  QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;
+  QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects; // FIXME: remove unused entries in cleanup()
 
   //! stores the meta info of known Qt classes
   QHash<QByteArray, PythonQtClassInfo *>   _knownClassInfos;