PageRenderTime 34ms CodeModel.GetById 8ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/Modules/xxmodule.c

http://unladen-swallow.googlecode.com/
C | 379 lines | 286 code | 49 blank | 44 comment | 30 complexity | 5a2aefac9270597ab4e64fbd28bf3a36 MD5 | raw file
  1
  2/* Use this file as a template to start implementing a module that
  3   also declares object types. All occurrences of 'Xxo' should be changed
  4   to something reasonable for your objects. After that, all other
  5   occurrences of 'xx' should be changed to something reasonable for your
  6   module. If your module is named foo your sourcefile should be named
  7   foomodule.c.
  8
  9   You will probably want to delete all references to 'x_attr' and add
 10   your own types of attributes instead.  Maybe you want to name your
 11   local variables other than 'self'.  If your object type is needed in
 12   other files, you'll have to create a file "foobarobject.h"; see
 13   intobject.h for an example. */
 14
 15/* Xxo objects */
 16
 17#include "Python.h"
 18
 19static PyObject *ErrorObject;
 20
 21typedef struct {
 22	PyObject_HEAD
 23	PyObject	*x_attr;	/* Attributes dictionary */
 24} XxoObject;
 25
 26static PyTypeObject Xxo_Type;
 27
 28#define XxoObject_Check(v)	(Py_TYPE(v) == &Xxo_Type)
 29
 30static XxoObject *
 31newXxoObject(PyObject *arg)
 32{
 33	XxoObject *self;
 34	self = PyObject_New(XxoObject, &Xxo_Type);
 35	if (self == NULL)
 36		return NULL;
 37	self->x_attr = NULL;
 38	return self;
 39}
 40
 41/* Xxo methods */
 42
 43static void
 44Xxo_dealloc(XxoObject *self)
 45{
 46	Py_XDECREF(self->x_attr);
 47	PyObject_Del(self);
 48}
 49
 50static PyObject *
 51Xxo_demo(XxoObject *self, PyObject *args)
 52{
 53	if (!PyArg_ParseTuple(args, ":demo"))
 54		return NULL;
 55	Py_INCREF(Py_None);
 56	return Py_None;
 57}
 58
 59static PyMethodDef Xxo_methods[] = {
 60	{"demo",	(PyCFunction)Xxo_demo,	METH_VARARGS,
 61		PyDoc_STR("demo() -> None")},
 62	{NULL,		NULL}		/* sentinel */
 63};
 64
 65static PyObject *
 66Xxo_getattr(XxoObject *self, char *name)
 67{
 68	if (self->x_attr != NULL) {
 69		PyObject *v = PyDict_GetItemString(self->x_attr, name);
 70		if (v != NULL) {
 71			Py_INCREF(v);
 72			return v;
 73		}
 74	}
 75	return Py_FindMethod(Xxo_methods, (PyObject *)self, name);
 76}
 77
 78static int
 79Xxo_setattr(XxoObject *self, char *name, PyObject *v)
 80{
 81	if (self->x_attr == NULL) {
 82		self->x_attr = PyDict_New();
 83		if (self->x_attr == NULL)
 84			return -1;
 85	}
 86	if (v == NULL) {
 87		int rv = PyDict_DelItemString(self->x_attr, name);
 88		if (rv < 0)
 89			PyErr_SetString(PyExc_AttributeError,
 90			        "delete non-existing Xxo attribute");
 91		return rv;
 92	}
 93	else
 94		return PyDict_SetItemString(self->x_attr, name, v);
 95}
 96
 97static PyTypeObject Xxo_Type = {
 98	/* The ob_type field must be initialized in the module init function
 99	 * to be portable to Windows without using C++. */
100	PyVarObject_HEAD_INIT(NULL, 0)
101	"xxmodule.Xxo",		/*tp_name*/
102	sizeof(XxoObject),	/*tp_basicsize*/
103	0,			/*tp_itemsize*/
104	/* methods */
105	(destructor)Xxo_dealloc, /*tp_dealloc*/
106	0,			/*tp_print*/
107	(getattrfunc)Xxo_getattr, /*tp_getattr*/
108	(setattrfunc)Xxo_setattr, /*tp_setattr*/
109	0,			/*tp_compare*/
110	0,			/*tp_repr*/
111	0,			/*tp_as_number*/
112	0,			/*tp_as_sequence*/
113	0,			/*tp_as_mapping*/
114	0,			/*tp_hash*/
115        0,                      /*tp_call*/
116        0,                      /*tp_str*/
117        0,                      /*tp_getattro*/
118        0,                      /*tp_setattro*/
119        0,                      /*tp_as_buffer*/
120        Py_TPFLAGS_DEFAULT,     /*tp_flags*/
121        0,                      /*tp_doc*/
122        0,                      /*tp_traverse*/
123        0,                      /*tp_clear*/
124        0,                      /*tp_richcompare*/
125        0,                      /*tp_weaklistoffset*/
126        0,                      /*tp_iter*/
127        0,                      /*tp_iternext*/
128        0,                      /*tp_methods*/
129        0,                      /*tp_members*/
130        0,                      /*tp_getset*/
131        0,                      /*tp_base*/
132        0,                      /*tp_dict*/
133        0,                      /*tp_descr_get*/
134        0,                      /*tp_descr_set*/
135        0,                      /*tp_dictoffset*/
136        0,                      /*tp_init*/
137        0,                      /*tp_alloc*/
138        0,                      /*tp_new*/
139        0,                      /*tp_free*/
140        0,                      /*tp_is_gc*/
141};
142/* --------------------------------------------------------------------- */
143
144/* Function of two integers returning integer */
145
146PyDoc_STRVAR(xx_foo_doc,
147"foo(i,j)\n\
148\n\
149Return the sum of i and j.");
150
151static PyObject *
152xx_foo(PyObject *self, PyObject *args)
153{
154	long i, j;
155	long res;
156	if (!PyArg_ParseTuple(args, "ll:foo", &i, &j))
157		return NULL;
158	res = i+j; /* XXX Do something here */
159	return PyInt_FromLong(res);
160}
161
162
163/* Function of no arguments returning new Xxo object */
164
165static PyObject *
166xx_new(PyObject *self, PyObject *args)
167{
168	XxoObject *rv;
169
170	if (!PyArg_ParseTuple(args, ":new"))
171		return NULL;
172	rv = newXxoObject(args);
173	if (rv == NULL)
174		return NULL;
175	return (PyObject *)rv;
176}
177
178/* Example with subtle bug from extensions manual ("Thin Ice"). */
179
180static PyObject *
181xx_bug(PyObject *self, PyObject *args)
182{
183	PyObject *list, *item;
184
185	if (!PyArg_ParseTuple(args, "O:bug", &list))
186		return NULL;
187
188	item = PyList_GetItem(list, 0);
189	/* Py_INCREF(item); */
190	PyList_SetItem(list, 1, PyInt_FromLong(0L));
191	PyObject_Print(item, stdout, 0);
192	printf("\n");
193	/* Py_DECREF(item); */
194
195	Py_INCREF(Py_None);
196	return Py_None;
197}
198
199/* Test bad format character */
200
201static PyObject *
202xx_roj(PyObject *self, PyObject *args)
203{
204	PyObject *a;
205	long b;
206	if (!PyArg_ParseTuple(args, "O#:roj", &a, &b))
207		return NULL;
208	Py_INCREF(Py_None);
209	return Py_None;
210}
211
212
213/* ---------- */
214
215static PyTypeObject Str_Type = {
216	/* The ob_type field must be initialized in the module init function
217	 * to be portable to Windows without using C++. */
218	PyVarObject_HEAD_INIT(NULL, 0)
219	"xxmodule.Str",		/*tp_name*/
220	0,			/*tp_basicsize*/
221	0,			/*tp_itemsize*/
222	/* methods */
223	0,			/*tp_dealloc*/
224	0,			/*tp_print*/
225	0,			/*tp_getattr*/
226	0,			/*tp_setattr*/
227	0,			/*tp_compare*/
228	0,			/*tp_repr*/
229	0,			/*tp_as_number*/
230	0,			/*tp_as_sequence*/
231	0,			/*tp_as_mapping*/
232	0,			/*tp_hash*/
233	0,			/*tp_call*/
234	0,			/*tp_str*/
235	0,			/*tp_getattro*/
236	0,			/*tp_setattro*/
237	0,			/*tp_as_buffer*/
238	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
239	0,			/*tp_doc*/
240	0,			/*tp_traverse*/
241	0,			/*tp_clear*/
242	0,			/*tp_richcompare*/
243	0,			/*tp_weaklistoffset*/
244	0,			/*tp_iter*/
245	0,			/*tp_iternext*/
246	0,			/*tp_methods*/
247	0,			/*tp_members*/
248	0,			/*tp_getset*/
249	0, /* see initxx */	/*tp_base*/
250	0,			/*tp_dict*/
251	0,			/*tp_descr_get*/
252	0,			/*tp_descr_set*/
253	0,			/*tp_dictoffset*/
254	0,			/*tp_init*/
255	0,			/*tp_alloc*/
256	0,			/*tp_new*/
257	0,			/*tp_free*/
258	0,			/*tp_is_gc*/
259};
260
261/* ---------- */
262
263static PyObject *
264null_richcompare(PyObject *self, PyObject *other, int op)
265{
266	Py_INCREF(Py_NotImplemented);
267	return Py_NotImplemented;
268}
269
270static PyTypeObject Null_Type = {
271	/* The ob_type field must be initialized in the module init function
272	 * to be portable to Windows without using C++. */
273	PyVarObject_HEAD_INIT(NULL, 0)
274	"xxmodule.Null",	/*tp_name*/
275	0,			/*tp_basicsize*/
276	0,			/*tp_itemsize*/
277	/* methods */
278	0,			/*tp_dealloc*/
279	0,			/*tp_print*/
280	0,			/*tp_getattr*/
281	0,			/*tp_setattr*/
282	0,			/*tp_compare*/
283	0,			/*tp_repr*/
284	0,			/*tp_as_number*/
285	0,			/*tp_as_sequence*/
286	0,			/*tp_as_mapping*/
287	0,			/*tp_hash*/
288	0,			/*tp_call*/
289	0,			/*tp_str*/
290	0,			/*tp_getattro*/
291	0,			/*tp_setattro*/
292	0,			/*tp_as_buffer*/
293	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
294	0,			/*tp_doc*/
295	0,			/*tp_traverse*/
296	0,			/*tp_clear*/
297	null_richcompare,	/*tp_richcompare*/
298	0,			/*tp_weaklistoffset*/
299	0,			/*tp_iter*/
300	0,			/*tp_iternext*/
301	0,			/*tp_methods*/
302	0,			/*tp_members*/
303	0,			/*tp_getset*/
304	0, /* see initxx */	/*tp_base*/
305	0,			/*tp_dict*/
306	0,			/*tp_descr_get*/
307	0,			/*tp_descr_set*/
308	0,			/*tp_dictoffset*/
309	0,			/*tp_init*/
310	0,			/*tp_alloc*/
311	0, /* see initxx */	/*tp_new*/
312	0,			/*tp_free*/
313	0,			/*tp_is_gc*/
314};
315
316
317/* ---------- */
318
319
320/* List of functions defined in the module */
321
322static PyMethodDef xx_methods[] = {
323	{"roj",		xx_roj,		METH_VARARGS,
324		PyDoc_STR("roj(a,b) -> None")},
325	{"foo",		xx_foo,		METH_VARARGS,
326	 	xx_foo_doc},
327	{"new",		xx_new,		METH_VARARGS,
328		PyDoc_STR("new() -> new Xx object")},
329	{"bug",		xx_bug,		METH_VARARGS,
330		PyDoc_STR("bug(o) -> None")},
331	{NULL,		NULL}		/* sentinel */
332};
333
334PyDoc_STRVAR(module_doc,
335"This is a template module just for instruction.");
336
337/* Initialization function for the module (*must* be called initxx) */
338
339PyMODINIT_FUNC
340initxx(void)
341{
342	PyObject *m;
343
344	/* Due to cross platform compiler issues the slots must be filled
345	 * here. It's required for portability to Windows without requiring
346	 * C++. */
347	Null_Type.tp_base = &PyBaseObject_Type;
348	Null_Type.tp_new = PyType_GenericNew;
349	Str_Type.tp_base = &PyUnicode_Type;
350
351	/* Finalize the type object including setting type of the new type
352	 * object; doing it here is required for portability, too. */
353	if (PyType_Ready(&Xxo_Type) < 0)
354		return;
355
356	/* Create the module and add the functions */
357	m = Py_InitModule3("xx", xx_methods, module_doc);
358	if (m == NULL)
359		return;
360
361	/* Add some symbolic constants to the module */
362	if (ErrorObject == NULL) {
363		ErrorObject = PyErr_NewException("xx.error", NULL, NULL);
364		if (ErrorObject == NULL)
365			return;
366	}
367	Py_INCREF(ErrorObject);
368	PyModule_AddObject(m, "error", ErrorObject);
369
370	/* Add Str */
371	if (PyType_Ready(&Str_Type) < 0)
372		return;
373	PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
374
375	/* Add Null */
376	if (PyType_Ready(&Null_Type) < 0)
377		return;
378	PyModule_AddObject(m, "Null", (PyObject *)&Null_Type);
379}