Try to solve memory leak problems

libs/cturmit.c

 	char err_msg[128];
 	ssize_t arg_stk_sz, arg_int_max;
 	char *arg_expr;
-	int i;
+	int i, ret;
 	CTurmit *turmit;
-	PyObject *stack_size, *int_max, *expr, *keys;
+	PyObject *stack_size, *int_max, *expr, *keys, *asc_str;
 	PyObject *errtype, *errvalue, *errbck;
 	
 	PyErr_Fetch(&errtype, &errvalue, &errbck);
 	turmit  = (CTurmit*)PyMapping_GetItemString(kwds, "turmit");
 	if(turmit)
 	{
-		return _CTurmit_copy_init(self, turmit);
+		Py_XDECREF(errtype);
+		Py_XDECREF(errvalue);
+		Py_XDECREF(errbck);
+		ret = _CTurmit_copy_init(self, turmit);
+		Py_DECREF(turmit);
+		return ret;
 	}
 	PyErr_Restore(errtype, errvalue, errbck);
 
 			PyErr_Restore(errtype, errvalue, errbck);
 			snprintf(err_msg, 128, "1 positional argument expected \
 but %ld found", sz);
-			PyErr_SetString(PyExc_TypeError, err_msg);
-			return -1;
+			PyErr_SetString(PyExc_TypeError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 		stack_size = PySequence_GetItem(args, 0);
 	}
 		if(!PyLong_CheckExact(stack_size))
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_TypeError,
+			Py_DECREF(stack_size);
+			snprintf(err_msg, 128,
 				"stack_size expected to be an integer");
-			return -1;
+			PyErr_SetString(PyExc_TypeError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 		arg_stk_sz = PyLong_AsSsize_t(stack_size);
+		Py_DECREF(stack_size);
 		if(arg_stk_sz == (size_t)-1 && PyErr_Occurred())
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_ValueError,
+			snprintf(err_msg, 128,
 				"size_t overflow with stack_size");
-			return -1;
+			PyErr_SetString(PyExc_ValueError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 	}
 	else
 		if(!PyLong_CheckExact(int_max))
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_TypeError,
+			snprintf(err_msg, 128,
 				"int_max expected to be an integer");
-			return -1;
+			PyErr_SetString(PyExc_TypeError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 		arg_int_max = PyLong_AsSsize_t(int_max);
+		Py_DECREF(int_max);
 		if(arg_int_max == (size_t)-1 && PyErr_Occurred())
 		{
+			PyErr_Restore(errtype, errvalue, errbck);
 			PyErr_SetString(PyExc_TypeError,
 				"size_t overflow with stack_size");
+			PyErr_SetString(PyExc_ValueError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 	}
 	else
 		if(!PyUnicode_Check(expr) && !(expr = PyObject_Str(expr)))
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_TypeError,
+			snprintf(err_msg, 128,
 				"prog expected to be a string !");
-			return -1;
+			PyErr_SetString(PyExc_TypeError,
+				err_msg);
+			goto cturmit_init_error;
 		}
-		expr = PyUnicode_AsASCIIString(expr);
-		if(!expr)
+		asc_str = PyUnicode_AsASCIIString(expr);
+		Py_DECREF(expr);
+		if(!asc_str)
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_TypeError,
+			snprintf(err_msg, 128,
 				"prog expected to be an ASCII string");
-			return -1;
+			PyErr_SetString(PyExc_ValueError,
+				err_msg);
+			goto cturmit_init_error;
 		}
-		arg_expr = (char*)PyBytes_AsString(expr);
+		arg_expr = (char*)PyBytes_AsString(asc_str);
+		Py_DECREF(asc_str);
 		if(!arg_expr)
 		{
 			PyErr_Restore(errtype, errvalue, errbck);
-			PyErr_SetString(PyExc_TypeError,
+			snprintf(err_msg, 128,
 				"Unable to convert prog to Cstring");
-			return -1;
+			PyErr_SetString(PyExc_RuntimeError,
+				err_msg);
+			goto cturmit_init_error;
 		}
 	}
 	else
 		strncpy(err_msg, "Unrecognized arguments : '", 128);
 		for(i=0; i<PyList_Size(keys); i++)
 		{
+			asc_str = PyUnicode_AsASCIIString(
+						PyList_GetItem(keys, i));
 			strncat(err_msg,
-				(char*)PyBytes_AsString(
-					PyUnicode_AsASCIIString(
-						PyList_GetItem(keys, i))),
-				128);
+				(char*)PyBytes_AsString(asc_str),128);
 			strncat(err_msg, "', '", 128);
 		}
+		Py_DECREF(keys);
 		strncat(err_msg, "'", 128);
+		PyErr_Restore(errtype, errvalue, errbck);
 		PyErr_SetString(PyExc_RuntimeError,
 			err_msg);
-		return -1;
+		goto cturmit_init_error;
 	}
 
 	PyErr_Restore(errtype, errvalue, errbck);
 		TURMIT_AUTOCOMP);
 	if(self->turmit->err)
 	{
+		PyErr_Restore(errtype, errvalue, errbck);
 		snprintf(err_msg, 128,
 			"Unable to compile '%s' err : %s", arg_expr,
 			self->turmit->err_str);
 		PyErr_SetString(PyExc_ValueError,
 			err_msg);
-		return -1;
+		goto cturmit_init_error;
 	}
+	Py_XDECREF(errtype);
+	Py_XDECREF(errvalue);
+	Py_XDECREF(errbck);
 	return 0;
+
+	cturmit_init_error:
+		Py_XDECREF(errtype);
+		Py_XDECREF(errvalue);
+		Py_XDECREF(errbck);
+		return -1;
+
 }
 
 static PyObject *
 				err_msg);
 			Py_RETURN_NONE;
 		}
+                Py_DECREF(arg);
 	}
-
 	res = turmit_exec(self->turmit, exec_args);
 	return PyLong_FromUnsignedLongLong(res);
 }

libs/cturmit.h

 
 #include "turmit.h"
 
+/**
+ * @todo search for decref and memory leaks :/
+ */
+
 typedef struct
 {
 	PyObject VAR_HEAD;