Fixed memory leaks.

Used PyObject on attr functions.
Code style update.
Reviewer: Hugo Parente Lima <hugo.lima@openbossa.org>,
          Luciano Wolf <luciano.wolf@openbossa.org>

5 files changed, 149 insertions, 138 deletions

diff --git a/libpyside/dynamicqmetaobject.cpp b/libpyside/dynamicqmetaobject.cpp
index 0315946ca..cb4ec194b 100644
--- a/libpyside/dynamicqmetaobject.cpp
+++ b/libpyside/dynamicqmetaobject.cpp
@@ -89,7 +89,7 @@ QByteArray MethodData::type() const
     return m_type;
 }
 
-DynamicQMetaObject::DynamicQMetaObject(const char *className, const QMetaObject* metaObject)
+DynamicQMetaObject::DynamicQMetaObject(const char* className, const QMetaObject* metaObject)
 {
     d.superdata = metaObject;
     d.stringdata = 0;
@@ -105,7 +105,7 @@ DynamicQMetaObject::~DynamicQMetaObject()
     delete[] d.data;
 }
 
-void DynamicQMetaObject::addSignal(const char *signal, const char *type)
+void DynamicQMetaObject::addSignal(const char* signal, const char* type)
 {
     //search for a empty space
     MethodData blank;
@@ -125,7 +125,7 @@ void DynamicQMetaObject::addSignal(const char *signal, const char *type)
     updateMetaObject();
 }
 
-void DynamicQMetaObject::addSlot(const char *slot, const char *type)
+void DynamicQMetaObject::addSlot(const char* slot, const char* type)
 {
     //search for a empty space
     MethodData blank;
@@ -150,13 +150,14 @@ void DynamicQMetaObject::removeSlot(uint index)
     }
 }
 
-DynamicQMetaObject* DynamicQMetaObject::createBasedOn(PyObject *pyObj, PyTypeObject *type, const QMetaObject *base)
+DynamicQMetaObject* DynamicQMetaObject::createBasedOn(PyObject* pyObj, PyTypeObject* type, const QMetaObject* base)
 {
-    PyObject *key, *value;
+    PyObject* key;
+    PyObject* value;
     Py_ssize_t pos = 0;
 
     QString className(type->tp_name);
-    className = className.mid(className.lastIndexOf(".")+1);
+    className = className.mid(className.lastIndexOf('.')+1);
     DynamicQMetaObject *mo = new PySide::DynamicQMetaObject(className.toAscii(), base);
 
     while (PyDict_Next(type->tp_dict, &pos, &key, &value)) {
@@ -180,7 +181,7 @@ DynamicQMetaObject* DynamicQMetaObject::createBasedOn(PyObject *pyObj, PyTypeObj
         //Register Slots
         if (PyObject_HasAttrString(value, PYSIDE_SLOT_LIST_ATTR)) {
             PyObject *signature_list = PyObject_GetAttrString(value, PYSIDE_SLOT_LIST_ATTR);
-            for(Py_ssize_t i=0, i_max=PyList_Size(signature_list); i < i_max; i++) {
+            for(Py_ssize_t i = 0, i_max = PyList_Size(signature_list); i < i_max; i++) {
                 PyObject *signature = PyList_GET_ITEM(signature_list, i);
                 QString sig(PyString_AsString(signature));
                 //slot the slot type and signature
diff --git a/libpyside/dynamicqmetaobject.h b/libpyside/dynamicqmetaobject.h
index bec8dd3df..5da73a521 100644
--- a/libpyside/dynamicqmetaobject.h
+++ b/libpyside/dynamicqmetaobject.h
@@ -50,17 +50,17 @@ namespace PySide
 
 class MethodData
 {
-    public:
-        MethodData(){}
-        MethodData(const char *signature, const char *type);
-        void clear();
-        QByteArray signature() const;
-        QByteArray type() const;
-        bool operator==(const MethodData &other) const;
+public:
+    MethodData(){}
+    MethodData(const char *signature, const char *type);
+    void clear();
+    QByteArray signature() const;
+    QByteArray type() const;
+    bool operator==(const MethodData &other) const;
 
-    private:
-        QByteArray m_signature;
-        QByteArray m_type;
+private:
+    QByteArray m_signature;
+    QByteArray m_type;
 };
 
 class PYSIDE_API DynamicQMetaObject : public QMetaObject
@@ -76,7 +76,7 @@ public:
     void removeSlot(uint index);
 
     //Retrieve Python metadata to create QMetaObject (class name, signals, slot)
-    static DynamicQMetaObject *createBasedOn(PyObject *obj, PyTypeObject *type, const QMetaObject* base);
+    static DynamicQMetaObject* createBasedOn(PyObject* obj, PyTypeObject* type, const QMetaObject* base);
 
 private:
     QLinkedList<MethodData> m_signals;
diff --git a/libpyside/qsignal.cpp b/libpyside/qsignal.cpp
index 08bb29660..76d66f97e 100644
--- a/libpyside/qsignal.cpp
+++ b/libpyside/qsignal.cpp
@@ -1,5 +1,3 @@
-#define protected public
-
 #include <shiboken.h>
 #include <Python.h>
 #include <QDebug>
@@ -18,9 +16,9 @@ extern "C"
 typedef struct {
     PyObject_HEAD
     bool initialized;
-    char *signal_name;
-    char **signatures;
-    int signatures_size;
+    char* signalName;
+    char** signatures;
+    int signaturesSize;
 } SignalData;
 
 static int signal_init(PyObject*, PyObject*, PyObject*);
@@ -28,17 +26,17 @@ static void signal_free(void*);
 static void signal_instance_free(void*);
 
 //methods
-static PyObject* signal_instance_connect(PyObject *self, PyObject *args, PyObject *kw);
-static PyObject* signal_instance_disconnect(PyObject *self, PyObject *args);
-static PyObject* signal_instance_emit(PyObject *self, PyObject *args);
-static PyObject* signal_instance_get_item(PyObject *self, PyObject *key);
+static PyObject* signal_instance_connect(PyObject*, PyObject*, PyObject*);
+static PyObject* signal_instance_disconnect(PyObject*, PyObject*);
+static PyObject* signal_instance_emit(PyObject*, PyObject*);
+static PyObject* signal_instance_get_item(PyObject*, PyObject*);
 
 //aux
-static char* signal_build_signature(const char *name, const char *signature);
-static const char* signal_get_type_name(PyObject *type);
-static void signal_append_signature(SignalData *self, char *signature);
-static void signal_instance_initialize(PyObject *instance, PyObject *name, SignalData *data, PyObject *source, int index);
-static char* signal_parse_signature(PyObject *args);
+static char* signal_build_signature(const char*, const char*);
+static char* signal_get_type_name(PyObject*);
+static void signal_append_signature(SignalData*, char*);
+static void signal_instance_initialize(PyObject*, PyObject*, SignalData*, PyObject *, int);
+static char* signal_parse_signature(PyObject*);
 
 PyTypeObject Signal_Type = {
     PyObject_HEAD_INIT(0)
@@ -172,12 +170,12 @@ PyAPI_FUNC(void) init_signal(PyObject* module)
 } // extern "C"
 
 
-PyObject* signal_instance_get_item(PyObject *self, PyObject *key)
+PyObject* signal_instance_get_item(PyObject* self, PyObject* key)
 {
-    SignalInstanceData *data = reinterpret_cast<SignalInstanceData*>(self);
-    char *sig_key = signal_parse_signature(key);
-    char *sig = signal_build_signature(data->signal_name, sig_key);
-    free(sig_key);
+    SignalInstanceData* data = reinterpret_cast<SignalInstanceData*>(self);
+    char* sigKey = signal_parse_signature(key);
+    char* sig = signal_build_signature(data->signalName, sigKey);
+    free(sigKey);
 
     while(data) {
         if (strcmp(data->signature, sig) == 0) {
@@ -192,32 +190,32 @@ PyObject* signal_instance_get_item(PyObject *self, PyObject *key)
     return 0;
 }
 
-void signal_update_source(PyObject *source)
+void signal_update_source(PyObject* source)
 {
-    PyObject *key, *value;
+    PyObject* key;
+    PyObject* value;
     Py_ssize_t pos = 0;
-    PyTypeObject *obType = source->ob_type;
+    PyTypeObject* obType = source->ob_type;
 
     while (PyDict_Next(obType->tp_dict, &pos, &key, &value)) {
         if (value->ob_type == &Signal_Type) {
-            PyObject *signal_instance = (PyObject*)PyObject_New(SignalInstanceData, &SignalInstance_Type);
-            signal_instance_initialize(signal_instance, key, reinterpret_cast<SignalData*>(value), source, 0);
-            PyObject_SetAttr(source, key, signal_instance);
-            Py_DECREF(signal_instance);
+            Shiboken::AutoDecRef signalInstance(reinterpret_cast<PyObject*>(PyObject_New(SignalInstanceData, &SignalInstance_Type)));
+            signal_instance_initialize(signalInstance, key, reinterpret_cast<SignalData*>(value), source, 0);
+            PyObject_SetAttr(source, key, signalInstance);
         }
     }
 }
 
-const char* signal_get_type_name(PyObject *type)
+char* signal_get_type_name(PyObject* type)
 {
     if (PyType_Check(type)) {
         //tp_name return the full name
-        Shiboken::AutoDecRef type_name(PyObject_GetAttrString(type, "__name__"));
-        return PyString_AS_STRING((PyObject*)type_name);
+        Shiboken::AutoDecRef typeName(PyObject_GetAttrString(type, "__name__"));
+        return strdup(PyString_AS_STRING(typeName.object()));
     } else if (PyString_Check(type)) {
-        return PyString_AS_STRING(type);
+        return strdup(PyString_AS_STRING(type));
     }
-    return "";
+    return 0;
 }
 
 char* signal_build_signature(const char *name, const char *signature)
@@ -232,17 +230,19 @@ char* signal_parse_signature(PyObject *args)
     char *signature = 0;
 
     if (args && !PySequence_Check(args) && (args != Py_None && args))
-        return strdup(signal_get_type_name(args));
+        return signal_get_type_name(args);
 
-    for(Py_ssize_t i=0, i_max=PySequence_Size(args); i < i_max; i++) {
+    for(Py_ssize_t i = 0, i_max = PySequence_Size(args); i < i_max; i++) {
         Shiboken::AutoDecRef arg(PySequence_ITEM(args, i));
-        const char *type_name = signal_get_type_name(arg);
-        if (strlen(type_name) > 0) {
+        char* typeName = signal_get_type_name(arg);
+        if (typeName) {
             if (signature) {
+                signature = reinterpret_cast<char*>(realloc(signature, (strlen(signature) + 1 + strlen(typeName)) * sizeof(char*)));
                 signature = strcat(signature, ",");
-                signature = strcat(signature, type_name);
+                signature = strcat(signature, typeName);
+                free(typeName);
             } else {
-                signature = strdup(type_name);
+                signature = typeName;
             }
         }
     }
@@ -250,49 +250,48 @@ char* signal_parse_signature(PyObject *args)
     return signature;
 }
 
-void signal_append_signature(SignalData *self, char *signature)
+void signal_append_signature(SignalData* self, char* signature)
 {
-    self->signatures_size++;
+    self->signaturesSize++;
 
-    if (self->signatures_size > 1) {
-        self->signatures = (char**) realloc(self->signatures, sizeof(char**) * self->signatures_size);
+    if (self->signaturesSize > 1) {
+        self->signatures = (char**) realloc(self->signatures, sizeof(char**) * self->signaturesSize);
     } else {
         self->signatures = (char**) malloc(sizeof(char**));
     }
-    self->signatures[self->signatures_size-1] = signature;
+    self->signatures[self->signaturesSize-1] = signature;
 }
 
-int signal_init(PyObject *self, PyObject *args, PyObject *kwds)
+int signal_init(PyObject* self, PyObject* args, PyObject* kwds)
 {
     static PyObject *emptyTuple = 0;
     static const char *kwlist[] = {"name", 0};
-    char* arg_name = 0;
+    char* argName = 0;
 
     if (emptyTuple == 0)
         emptyTuple = PyTuple_New(0);
 
     if (!PyArg_ParseTupleAndKeywords(emptyTuple, kwds,
-                                     "|s:QtCore."SIGNAL_CLASS_NAME, (char**) kwlist, &arg_name))
+                                     "|s:QtCore."SIGNAL_CLASS_NAME, (char**) kwlist, &argName))
         return 0;
 
-    bool tupled_args = false;
+    bool tupledArgs = false;
     SignalData *data = reinterpret_cast<SignalData*>(self);
-    if (arg_name) {
-        data->signal_name = strdup(arg_name);
+    if (argName) {
+        data->signalName = strdup(argName);
     }
 
-    for(Py_ssize_t i=0, i_max=PyTuple_Size(args); i < i_max; i++) {
+    for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
         PyObject *arg = PyTuple_GET_ITEM(args, i);
         if (PySequence_Check(arg)) {
-            tupled_args = true;
+            tupledArgs = true;
             signal_append_signature(data, signal_parse_signature(arg));
         }
     }
 
-    if (!tupled_args)
+    if (!tupledArgs)
         signal_append_signature(data, signal_parse_signature(args));
 
-
     return 1;
 }
 
@@ -301,25 +300,25 @@ void signal_free(void *self)
     PyObject *pySelf = reinterpret_cast<PyObject*>(self);
     SignalData *data = reinterpret_cast<SignalData*>(self);
 
-    for(int i=0, i_max=data->signatures_size; i < i_max; i++) {
+    for(int i = 0, i_max = data->signaturesSize; i < i_max; i++) {
         if (data->signatures[i])
             free(data->signatures[i]);
     }
 
     free(data->signatures);
-    free(data->signal_name);
+    free(data->signalName);
     data->initialized = false;
-    data->signatures_size = 0;
+    data->signaturesSize = 0;
 
     pySelf->ob_type->tp_base->tp_free(self);
 }
 
-void signal_instance_free(void *self)
+void signal_instance_free(void* self)
 {
     PyObject *pySelf = reinterpret_cast<PyObject*>(self);
     SignalInstanceData *data = reinterpret_cast<SignalInstanceData*>(self);
 
-    free(data->signal_name);
+    free(data->signalName);
     free(data->signature);
 
     while(data) {
@@ -329,23 +328,23 @@ void signal_instance_free(void *self)
     pySelf->ob_type->tp_base->tp_free(self);
 }
 
-void signal_instance_initialize(PyObject *instance, PyObject *name, SignalData *data, PyObject *source, int index)
+void signal_instance_initialize(PyObject* instance, PyObject* name, SignalData* data, PyObject* source, int index)
 {
     if (data->initialized)
         return;
 
     SignalInstanceData *self = reinterpret_cast<SignalInstanceData*>(instance);
-    if (data->signal_name)
-        self->signal_name = strdup(data->signal_name);
+    if (data->signalName)
+        self->signalName = strdup(data->signalName);
     else
-        self->signal_name = strdup(PyString_AsString(name));
+        self->signalName = strdup(PyString_AsString(name));
 
     self->source = source;
-    self->signature = signal_build_signature(self->signal_name, data->signatures[index]);
+    self->signature = signal_build_signature(self->signalName, data->signatures[index]);
     index++;
 
-    if (index < data->signatures_size) {
-        self->next = (PyObject*)PyObject_New(SignalInstanceData, &SignalInstance_Type);
+    if (index < data->signaturesSize) {
+        self->next = reinterpret_cast<PyObject*>(PyObject_New(SignalInstanceData, &SignalInstance_Type));
         signal_instance_initialize(self->next, name, data, source, index);
     }
 
@@ -353,7 +352,7 @@ void signal_instance_initialize(PyObject *instance, PyObject *name, SignalData *
         data->initialized = true;
 }
 
-PyObject* signal_instance_connect(PyObject *self, PyObject *args, PyObject *kwds)
+PyObject* signal_instance_connect(PyObject* self, PyObject* args, PyObject* kwds)
 {
     PyObject *slot;
     PyObject *type;
@@ -400,7 +399,7 @@ PyObject* signal_instance_connect(PyObject *self, PyObject *args, PyObject *kwds
     return 0;
 }
 
-PyObject* signal_instance_disconnect(PyObject *self, PyObject *args)
+PyObject* signal_instance_disconnect(PyObject* self, PyObject* args)
 {
     SignalInstanceData *source = reinterpret_cast<SignalInstanceData*>(self);
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
@@ -443,7 +442,7 @@ PyObject* signal_instance_disconnect(PyObject *self, PyObject *args)
     return 0;
 }
 
-PyObject* signal_instance_emit(PyObject *self, PyObject *args)
+PyObject* signal_instance_emit(PyObject* self, PyObject* args)
 {
     SignalInstanceData *source = reinterpret_cast<SignalInstanceData*>(self);
 
@@ -460,11 +459,11 @@ PyObject* signal_instance_emit(PyObject *self, PyObject *args)
     return PyObject_CallObject(pyMethod, tupleArgs);
 }
 
-PyObject* signal_new(const char *name, ...)
+PyObject* signal_new(const char* name, ...)
 {
     va_list listSignatures;
-    char *sig;
-    SignalData *self = PyObject_New(SignalData, &Signal_Type);
+    char* sig;
+    SignalData* self = PyObject_New(SignalData, &Signal_Type);
 
     va_start(listSignatures, name);
     sig = va_arg(listSignatures, char*);
diff --git a/libpyside/qsignal.h b/libpyside/qsignal.h
index d39d2bb9d..2ba5e984e 100644
--- a/libpyside/qsignal.h
+++ b/libpyside/qsignal.h
@@ -1,5 +1,5 @@
-#ifndef QSIGNAL_H
-#define QSIGNAL_H
+#ifndef PYSIDE_SIGNAL_H
+#define PYSIDE_SIGNAL_H
 
 #include <pysidemacros.h>
 #include <Python.h>
@@ -10,10 +10,10 @@ namespace PySide
 
 typedef struct {
     PyObject_HEAD
-    char *signal_name;
-    char *signature;
-    PyObject *source;
-    PyObject *next;
+    char* signalName;
+    char* signature;
+    PyObject* source;
+    PyObject* next;
 } SignalInstanceData;
 
 
@@ -21,10 +21,11 @@ extern "C"
 {
     PyAPI_DATA(PyTypeObject) Signal_Type;
     PyAPI_DATA(PyTypeObject) SignalInstance_Type;
-    PYSIDE_API PyAPI_FUNC(PyObject*) signal_new(const char *name, ...);
+    PYSIDE_API PyAPI_FUNC(PyObject*) signal_new(const char* name, ...);
 }; //extern "C"
 
-PYSIDE_API void signal_update_source(PyObject *source);
+PYSIDE_API void signal_update_source(PyObject* source);
 
 } //namespace PySide
+
 #endif
diff --git a/libpyside/qslot.cpp b/libpyside/qslot.cpp
index 510f0558e..85ab30d71 100644
--- a/libpyside/qslot.cpp
+++ b/libpyside/qslot.cpp
@@ -8,16 +8,20 @@
 typedef struct
 {
     PyObject_HEAD
-    char* slot_name;
+    char* slotName;
     char* args;
-    char* result_type;
+    char* resultType;
 } SlotData;
 
 extern "C"
 {
 
-static int slot_init(PyObject *self, PyObject *arg, PyObject *kw);
-static PyObject* slot_call(PyObject *self, PyObject *arg, PyObject *kw);
+static int slot_init(PyObject*, PyObject*, PyObject*);
+static PyObject* slot_call(PyObject*, PyObject*, PyObject*);
+
+//aux
+static char* slot_get_type_name(PyObject*);
+
 
 // Class Definition -----------------------------------------------
 static PyTypeObject Slot_Type = {
@@ -70,7 +74,7 @@ static PyTypeObject Slot_Type = {
     0,                         /*tp_del */
 };
 
-PyAPI_FUNC(void) init_slot(PyObject* module)
+PyAPI_FUNC(void) init_slot(PyObject *module)
 {
     if (PyType_Ready(&Slot_Type) < 0)
         return;
@@ -82,91 +86,97 @@ PyAPI_FUNC(void) init_slot(PyObject* module)
 
 } // extern "C"
 
-static const char* slot_get_type_name(PyObject *type)
+char* slot_get_type_name(PyObject *type)
 {
     if (PyType_Check(type)) {
         //tp_name return the full name
-        Shiboken::AutoDecRef type_name(PyObject_GetAttrString(type, "__name__"));
-        return PyString_AS_STRING((PyObject*)type_name);
+        Shiboken::AutoDecRef typeName(PyObject_GetAttrString(type, "__name__"));
+        return strdup(PyString_AS_STRING(typeName.object()));
     } else if (PyString_Check(type)) {
-        return PyString_AS_STRING(type);
+        return strdup(PyString_AS_STRING(type));
     }
-    return "";
+    return 0;
 }
 
-static int slot_init(PyObject *self, PyObject *args, PyObject *kw)
+int slot_init(PyObject *self, PyObject *args, PyObject *kw)
 {
     static PyObject *emptyTuple = 0;
     static const char *kwlist[] = {"name", "result", 0};
-    char* arg_name = 0;
-    PyObject* arg_result = 0;
+    char* argName = 0;
+    PyObject* argResult = 0;
 
     if (emptyTuple == 0)
         emptyTuple = PyTuple_New(0);
 
-    if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sO:QtCore."SLOT_DEC_NAME, (char**) kwlist, &arg_name, &arg_result))
+    if (!PyArg_ParseTupleAndKeywords(emptyTuple, kw, "|sO:QtCore."SLOT_DEC_NAME, (char**) kwlist, &argName, &argResult))
         return 0;
 
     SlotData *data = reinterpret_cast<SlotData*>(self);
-    for(Py_ssize_t i=0, i_max=PyTuple_Size(args); i < i_max; i++) {
-        PyObject *arg_type = PyTuple_GET_ITEM(args, i);
-        const char *type_name = slot_get_type_name(arg_type);
-        if (strlen(type_name) > 0) {
+    for(Py_ssize_t i = 0, i_max = PyTuple_Size(args); i < i_max; i++) {
+        PyObject *argType = PyTuple_GET_ITEM(args, i);
+        char *typeName = slot_get_type_name(argType);
+        if (typeName) {
             if (data->args) {
+                data->args = reinterpret_cast<char*>(realloc(data->args, (strlen(data->args) + 1 + strlen(typeName)) * sizeof(char*)));
                 data->args = strcat(data->args, ",");
-                data->args = strcat(data->args, type_name);
+                data->args = strcat(data->args, typeName);
+                free(typeName);
             } else {
-                data->args = strdup(type_name);
+                data->args = typeName;
             }
         }
     }
 
-    if (arg_name)
-        data->slot_name = strdup(arg_name);
+    if (argName)
+        data->slotName = strdup(argName);
 
-    if (arg_result)
-        data->result_type = strdup(slot_get_type_name(arg_result));
+    if (argResult)
+        data->resultType = slot_get_type_name(argResult);
     else
-        data->result_type = strdup("void");
+        data->resultType = strdup("void");
 
     return 1;
 }
 
-static PyObject* slot_call(PyObject *self, PyObject *args, PyObject *kw)
+PyObject* slot_call(PyObject* self, PyObject* args, PyObject* kw)
 {
-    PyObject *callback;
+    static PyObject* pySlotName = 0;
+    PyObject* callback;
     callback = PyTuple_GetItem(args, 0);
     Py_INCREF(callback);
 
     if (PyFunction_Check(callback)) {
         SlotData *data = reinterpret_cast<SlotData*>(self);
 
-        if (!data->slot_name) {
-            PyObject *func_name = ((PyFunctionObject*)callback)->func_name;
-            data->slot_name = strdup(PyString_AS_STRING(func_name));
+        if (!data->slotName) {
+            PyObject *funcName = reinterpret_cast<PyFunctionObject*>(callback)->func_name;
+            data->slotName = strdup(PyString_AS_STRING(funcName));
         }
 
         QString signature;
-        signature.sprintf("%s %s(%s)", data->result_type, data->slot_name, data->args);
+        signature.sprintf("%s %s(%s)", data->resultType, data->slotName, data->args);
+
+        if (!pySlotName)
+            pySlotName = PyString_FromString(PYSIDE_SLOT_LIST_ATTR);
 
         PyObject *pySignature = PyString_FromString(QMetaObject::normalizedSignature(signature.toAscii()));
-        PyObject *signature_list = 0;
-        if (PyObject_HasAttrString(callback, PYSIDE_SLOT_LIST_ATTR)) {
-            signature_list = PyObject_GetAttrString(callback, PYSIDE_SLOT_LIST_ATTR);
+        PyObject *signatureList = 0;
+        if (PyObject_HasAttr(callback, pySlotName)) {
+            signatureList = PyObject_GetAttr(callback, pySlotName);
         } else {
-            signature_list = PyList_New(0);
-            PyObject_SetAttrString(callback, PYSIDE_SLOT_LIST_ATTR, signature_list);
-            Py_DECREF(signature_list);
+            signatureList = PyList_New(0);
+            PyObject_SetAttr(callback, pySlotName, signatureList);
+            Py_DECREF(signatureList);
         }
 
-        PyList_Append(signature_list, pySignature);
+        PyList_Append(signatureList, pySignature);
         Py_DECREF(pySignature);
 
         //clear data
-        free(data->slot_name);
-        data->slot_name = 0;
-        free(data->result_type);
-        data->result_type = 0;
+        free(data->slotName);
+        data->slotName = 0;
+        free(data->resultType);
+        data->resultType = 0;
         free(data->args);
         data->args = 0;
         return callback;