Merged revisions 81782 via svnmerge from
[python/dscho.git] / Modules / xxmodule.c
blob92c7673df9732fcbc25415d455e80aaf14a0582c
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.
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. */
15 /* Xxo objects */
17 #include "Python.h"
19 static PyObject *ErrorObject;
21 typedef struct {
22 PyObject_HEAD
23 PyObject *x_attr; /* Attributes dictionary */
24 } XxoObject;
26 static PyTypeObject Xxo_Type;
28 #define XxoObject_Check(v) (Py_TYPE(v) == &Xxo_Type)
30 static XxoObject *
31 newXxoObject(PyObject *arg)
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;
41 /* Xxo methods */
43 static void
44 Xxo_dealloc(XxoObject *self)
46 Py_XDECREF(self->x_attr);
47 PyObject_Del(self);
50 static PyObject *
51 Xxo_demo(XxoObject *self, PyObject *args)
53 if (!PyArg_ParseTuple(args, ":demo"))
54 return NULL;
55 Py_INCREF(Py_None);
56 return Py_None;
59 static PyMethodDef Xxo_methods[] = {
60 {"demo", (PyCFunction)Xxo_demo, METH_VARARGS,
61 PyDoc_STR("demo() -> None")},
62 {NULL, NULL} /* sentinel */
65 static PyObject *
66 Xxo_getattro(XxoObject *self, PyObject *name)
68 if (self->x_attr != NULL) {
69 PyObject *v = PyDict_GetItem(self->x_attr, name);
70 if (v != NULL) {
71 Py_INCREF(v);
72 return v;
75 return PyObject_GenericGetAttr((PyObject *)self, name);
78 static int
79 Xxo_setattr(XxoObject *self, char *name, PyObject *v)
81 if (self->x_attr == NULL) {
82 self->x_attr = PyDict_New();
83 if (self->x_attr == NULL)
84 return -1;
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;
93 else
94 return PyDict_SetItemString(self->x_attr, name, v);
97 static 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)0, /*tp_getattr*/
108 (setattrfunc)Xxo_setattr, /*tp_setattr*/
109 0, /*tp_reserved*/
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 (getattrofunc)Xxo_getattro, /*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 Xxo_methods, /*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*/
142 /* --------------------------------------------------------------------- */
144 /* Function of two integers returning integer */
146 PyDoc_STRVAR(xx_foo_doc,
147 "foo(i,j)\n\
149 Return the sum of i and j.");
151 static PyObject *
152 xx_foo(PyObject *self, PyObject *args)
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 PyLong_FromLong(res);
163 /* Function of no arguments returning new Xxo object */
165 static PyObject *
166 xx_new(PyObject *self, PyObject *args)
168 XxoObject *rv;
170 if (!PyArg_ParseTuple(args, ":new"))
171 return NULL;
172 rv = newXxoObject(args);
173 if (rv == NULL)
174 return NULL;
175 return (PyObject *)rv;
178 /* Example with subtle bug from extensions manual ("Thin Ice"). */
180 static PyObject *
181 xx_bug(PyObject *self, PyObject *args)
183 PyObject *list, *item;
185 if (!PyArg_ParseTuple(args, "O:bug", &list))
186 return NULL;
188 item = PyList_GetItem(list, 0);
189 /* Py_INCREF(item); */
190 PyList_SetItem(list, 1, PyLong_FromLong(0L));
191 PyObject_Print(item, stdout, 0);
192 printf("\n");
193 /* Py_DECREF(item); */
195 Py_INCREF(Py_None);
196 return Py_None;
199 /* Test bad format character */
201 static PyObject *
202 xx_roj(PyObject *self, PyObject *args)
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;
213 /* ---------- */
215 static 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_reserved*/
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 PyInit_xx */ /*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*/
261 /* ---------- */
263 static PyObject *
264 null_richcompare(PyObject *self, PyObject *other, int op)
266 Py_INCREF(Py_NotImplemented);
267 return Py_NotImplemented;
270 static 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_reserved*/
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 PyInit_xx */ /*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 PyInit_xx */ /*tp_new*/
312 0, /*tp_free*/
313 0, /*tp_is_gc*/
317 /* ---------- */
320 /* List of functions defined in the module */
322 static 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 */
334 PyDoc_STRVAR(module_doc,
335 "This is a template module just for instruction.");
337 /* Initialization function for the module (*must* be called PyInit_xx) */
340 static struct PyModuleDef xxmodule = {
341 PyModuleDef_HEAD_INIT,
342 "xx",
343 module_doc,
345 xx_methods,
346 NULL,
347 NULL,
348 NULL,
349 NULL
352 PyMODINIT_FUNC
353 PyInit_xx(void)
355 PyObject *m = NULL;
357 /* Due to cross platform compiler issues the slots must be filled
358 * here. It's required for portability to Windows without requiring
359 * C++. */
360 Null_Type.tp_base = &PyBaseObject_Type;
361 Null_Type.tp_new = PyType_GenericNew;
362 Str_Type.tp_base = &PyUnicode_Type;
364 /* Finalize the type object including setting type of the new type
365 * object; doing it here is required for portability, too. */
366 if (PyType_Ready(&Xxo_Type) < 0)
367 goto fail;
369 /* Create the module and add the functions */
370 m = PyModule_Create(&xxmodule);
371 if (m == NULL)
372 goto fail;
374 /* Add some symbolic constants to the module */
375 if (ErrorObject == NULL) {
376 ErrorObject = PyErr_NewException("xx.error", NULL, NULL);
377 if (ErrorObject == NULL)
378 goto fail;
380 Py_INCREF(ErrorObject);
381 PyModule_AddObject(m, "error", ErrorObject);
383 /* Add Str */
384 if (PyType_Ready(&Str_Type) < 0)
385 goto fail;
386 PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
388 /* Add Null */
389 if (PyType_Ready(&Null_Type) < 0)
390 goto fail;
391 PyModule_AddObject(m, "Null", (PyObject *)&Null_Type);
392 return m;
393 fail:
394 Py_XDECREF(m);
395 return NULL;