talloc: use the system pytalloc-util for python3 as well
[sfrench/samba-autobuild/.git] / lib / talloc / pytalloc.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Python Talloc Module
4    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2010-2011
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <Python.h>
21 #include <talloc.h>
22 #include <pytalloc.h>
23 #include "pytalloc_private.h"
24
25 static PyTypeObject TallocObject_Type;
26
27 #if PY_MAJOR_VERSION >= 3
28 #define PyStr_FromFormat PyUnicode_FromFormat
29 #else
30 #define PyStr_FromFormat PyString_FromFormat
31 #endif
32
33 /* print a talloc tree report for a talloc python object */
34 static PyObject *pytalloc_report_full(PyObject *self, PyObject *args)
35 {
36         PyObject *py_obj = Py_None;
37
38         if (!PyArg_ParseTuple(args, "|O", &py_obj))
39                 return NULL;
40
41         if (py_obj == Py_None) {
42                 talloc_report_full(NULL, stdout);
43         } else {
44                 talloc_report_full(pytalloc_get_mem_ctx(py_obj), stdout);
45         }
46         return Py_None;
47 }
48
49 /* enable null tracking */
50 static PyObject *pytalloc_enable_null_tracking(PyObject *self)
51 {
52         talloc_enable_null_tracking();
53         return Py_None;
54 }
55
56 /* return the number of talloc blocks */
57 static PyObject *pytalloc_total_blocks(PyObject *self, PyObject *args)
58 {
59         PyObject *py_obj = Py_None;
60
61         if (!PyArg_ParseTuple(args, "|O", &py_obj))
62                 return NULL;
63
64         if (py_obj == Py_None) {
65                 return PyLong_FromLong(talloc_total_blocks(NULL));
66         }
67
68         return PyLong_FromLong(talloc_total_blocks(pytalloc_get_mem_ctx(py_obj)));
69 }
70
71 static PyMethodDef talloc_methods[] = {
72         { "report_full", (PyCFunction)pytalloc_report_full, METH_VARARGS,
73                 "show a talloc tree for an object"},
74         { "enable_null_tracking", (PyCFunction)pytalloc_enable_null_tracking, METH_NOARGS,
75                 "enable tracking of the NULL object"},
76         { "total_blocks", (PyCFunction)pytalloc_total_blocks, METH_VARARGS,
77                 "return talloc block count"},
78         { NULL }
79 };
80
81 /**
82  * Default (but only slightly more useful than the default) implementation of Repr().
83  */
84 static PyObject *pytalloc_default_repr(PyObject *obj)
85 {
86         pytalloc_Object *talloc_obj = (pytalloc_Object *)obj;
87         PyTypeObject *type = (PyTypeObject*)PyObject_Type(obj);
88
89         return PyStr_FromFormat("<%s talloc object at 0x%p>",
90                                 type->tp_name, talloc_obj->ptr);
91 }
92
93 /**
94  * Simple dealloc for talloc-wrapping PyObjects
95  */
96 static void pytalloc_dealloc(PyObject* self)
97 {
98         pytalloc_Object *obj = (pytalloc_Object *)self;
99         assert(talloc_unlink(NULL, obj->talloc_ctx) != -1);
100         obj->talloc_ctx = NULL;
101         self->ob_type->tp_free(self);
102 }
103
104 /**
105  * Default (but only slightly more useful than the default) implementation of cmp.
106  */
107 #if PY_MAJOR_VERSION >= 3
108 static PyObject *pytalloc_default_richcmp(PyObject *obj1, PyObject *obj2, int op)
109 {
110         void *ptr1;
111         void *ptr2;
112         if (Py_TYPE(obj1) == Py_TYPE(obj2)) {
113                 /* When types match, compare pointers */
114                 ptr1 = pytalloc_get_ptr(obj1);
115                 ptr2 = pytalloc_get_ptr(obj2);
116         } else if (PyObject_TypeCheck(obj2, &TallocObject_Type)) {
117                 /* Otherwise, compare types */
118                 ptr1 = Py_TYPE(obj1);
119                 ptr2 = Py_TYPE(obj2);
120         } else {
121                 Py_INCREF(Py_NotImplemented);
122                 return Py_NotImplemented;
123         }
124         switch (op) {
125                 case Py_EQ: return PyBool_FromLong(ptr1 == ptr2);
126                 case Py_NE: return PyBool_FromLong(ptr1 != ptr2);
127                 case Py_LT: return PyBool_FromLong(ptr1 < ptr2);
128                 case Py_GT: return PyBool_FromLong(ptr1 > ptr2);
129                 case Py_LE: return PyBool_FromLong(ptr1 <= ptr2);
130                 case Py_GE: return PyBool_FromLong(ptr1 >= ptr2);
131         }
132         Py_INCREF(Py_NotImplemented);
133         return Py_NotImplemented;
134 }
135 #else
136 static int pytalloc_default_cmp(PyObject *_obj1, PyObject *_obj2)
137 {
138         pytalloc_Object *obj1 = (pytalloc_Object *)_obj1,
139                                          *obj2 = (pytalloc_Object *)_obj2;
140         if (obj1->ob_type != obj2->ob_type)
141                 return ((char *)obj1->ob_type - (char *)obj2->ob_type);
142
143         return ((char *)pytalloc_get_ptr(obj1) - (char *)pytalloc_get_ptr(obj2));
144 }
145 #endif
146
147 static PyTypeObject TallocObject_Type = {
148         .tp_name = "talloc.Object",
149         .tp_doc = "Python wrapper for a talloc-maintained object.",
150         .tp_basicsize = sizeof(pytalloc_Object),
151         .tp_dealloc = (destructor)pytalloc_dealloc,
152         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
153         .tp_repr = pytalloc_default_repr,
154 #if PY_MAJOR_VERSION >= 3
155         .tp_richcompare = pytalloc_default_richcmp,
156 #else
157         .tp_compare = pytalloc_default_cmp,
158 #endif
159 };
160
161 /**
162  * Default (but only slightly more useful than the default) implementation of Repr().
163  */
164 static PyObject *pytalloc_base_default_repr(PyObject *obj)
165 {
166         pytalloc_BaseObject *talloc_obj = (pytalloc_BaseObject *)obj;
167         PyTypeObject *type = (PyTypeObject*)PyObject_Type(obj);
168
169         return PyStr_FromFormat("<%s talloc based object at %p>",
170                                 type->tp_name, talloc_obj->ptr);
171 }
172
173 /**
174  * Simple dealloc for talloc-wrapping PyObjects
175  */
176 static void pytalloc_base_dealloc(PyObject* self)
177 {
178         pytalloc_BaseObject *obj = (pytalloc_BaseObject *)self;
179         assert(talloc_unlink(NULL, obj->talloc_ctx) != -1);
180         obj->talloc_ctx = NULL;
181         self->ob_type->tp_free(self);
182 }
183
184 /**
185  * Default (but only slightly more useful than the default) implementation of cmp.
186  */
187 #if PY_MAJOR_VERSION >= 3
188 static PyObject *pytalloc_base_default_richcmp(PyObject *obj1, PyObject *obj2, int op)
189 {
190         void *ptr1;
191         void *ptr2;
192         if (Py_TYPE(obj1) == Py_TYPE(obj2)) {
193                 /* When types match, compare pointers */
194                 ptr1 = pytalloc_get_ptr(obj1);
195                 ptr2 = pytalloc_get_ptr(obj2);
196         } else if (PyObject_TypeCheck(obj2, &TallocObject_Type)) {
197                 /* Otherwise, compare types */
198                 ptr1 = Py_TYPE(obj1);
199                 ptr2 = Py_TYPE(obj2);
200         } else {
201                 Py_INCREF(Py_NotImplemented);
202                 return Py_NotImplemented;
203         }
204         switch (op) {
205                 case Py_EQ: return PyBool_FromLong(ptr1 == ptr2);
206                 case Py_NE: return PyBool_FromLong(ptr1 != ptr2);
207                 case Py_LT: return PyBool_FromLong(ptr1 < ptr2);
208                 case Py_GT: return PyBool_FromLong(ptr1 > ptr2);
209                 case Py_LE: return PyBool_FromLong(ptr1 <= ptr2);
210                 case Py_GE: return PyBool_FromLong(ptr1 >= ptr2);
211         }
212         Py_INCREF(Py_NotImplemented);
213         return Py_NotImplemented;
214 }
215 #else
216 static int pytalloc_base_default_cmp(PyObject *_obj1, PyObject *_obj2)
217 {
218         pytalloc_BaseObject *obj1 = (pytalloc_BaseObject *)_obj1,
219                                          *obj2 = (pytalloc_BaseObject *)_obj2;
220         if (obj1->ob_type != obj2->ob_type)
221                 return ((char *)obj1->ob_type - (char *)obj2->ob_type);
222
223         return ((char *)pytalloc_get_ptr(obj1) - (char *)pytalloc_get_ptr(obj2));
224 }
225 #endif
226
227 static PyTypeObject TallocBaseObject_Type = {
228         .tp_name = "talloc.BaseObject",
229         .tp_doc = "Python wrapper for a talloc-maintained object.",
230         .tp_basicsize = sizeof(pytalloc_BaseObject),
231         .tp_dealloc = (destructor)pytalloc_base_dealloc,
232         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
233         .tp_repr = pytalloc_base_default_repr,
234 #if PY_MAJOR_VERSION >= 3
235         .tp_richcompare = pytalloc_base_default_richcmp,
236 #else
237         .tp_compare = pytalloc_base_default_cmp,
238 #endif
239 };
240
241 static PyTypeObject TallocGenericObject_Type = {
242         .tp_name = "talloc.GenericObject",
243         .tp_doc = "Python wrapper for a talloc-maintained object.",
244         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
245         .tp_base = &TallocBaseObject_Type,
246         .tp_basicsize = sizeof(pytalloc_BaseObject),
247 };
248
249 #define MODULE_DOC PyDoc_STR("Python wrapping of talloc-maintained objects.")
250
251 #if PY_MAJOR_VERSION >= 3
252 static struct PyModuleDef moduledef = {
253     PyModuleDef_HEAD_INIT,
254     .m_name = "talloc",
255     .m_doc = MODULE_DOC,
256     .m_size = -1,
257     .m_methods = talloc_methods,
258 };
259 #endif
260
261 static PyObject *module_init(void);
262 static PyObject *module_init(void)
263 {
264         PyObject *m;
265
266         if (PyType_Ready(&TallocObject_Type) < 0)
267                 return NULL;
268
269         if (PyType_Ready(&TallocBaseObject_Type) < 0)
270                 return NULL;
271
272         if (PyType_Ready(&TallocGenericObject_Type) < 0)
273                 return NULL;
274
275 #if PY_MAJOR_VERSION >= 3
276         m = PyModule_Create(&moduledef);
277 #else
278         m = Py_InitModule3("talloc", talloc_methods, MODULE_DOC);
279 #endif
280         if (m == NULL)
281                 return NULL;
282
283         Py_INCREF(&TallocObject_Type);
284         PyModule_AddObject(m, "Object", (PyObject *)&TallocObject_Type);
285         Py_INCREF(&TallocBaseObject_Type);
286         PyModule_AddObject(m, "BaseObject", (PyObject *)&TallocBaseObject_Type);
287         Py_INCREF(&TallocGenericObject_Type);
288         PyModule_AddObject(m, "GenericObject", (PyObject *)&TallocGenericObject_Type);
289         return m;
290 }
291
292 #if PY_MAJOR_VERSION >= 3
293 PyMODINIT_FUNC PyInit_talloc(void);
294 PyMODINIT_FUNC PyInit_talloc(void)
295 {
296         return module_init();
297 }
298 #else
299 void inittalloc(void);
300 void inittalloc(void)
301 {
302         module_init();
303 }
304 #endif