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 floatobject.h for an example. */
14
15 /* Xxo objects */
16
17 #include "Python.h"
18
19 static PyObject *ErrorObject;
20
21 typedef struct {
22 PyObject_HEAD
23 PyObject *x_attr; /* Attributes dictionary */
24 } XxoObject;
25
26 static PyTypeObject Xxo_Type;
27
28 #define XxoObject_Check(v) (Py_TYPE(v) == &Xxo_Type)
29
30 static XxoObject *
newXxoObject(PyObject * arg)31 newXxoObject(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
43 static void
Xxo_dealloc(XxoObject * self)44 Xxo_dealloc(XxoObject *self)
45 {
46 Py_XDECREF(self->x_attr);
47 PyObject_Del(self);
48 }
49
50 static PyObject *
Xxo_demo(XxoObject * self,PyObject * args)51 Xxo_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
59 static PyMethodDef Xxo_methods[] = {
60 {"demo", (PyCFunction)Xxo_demo, METH_VARARGS,
61 PyDoc_STR("demo() -> None")},
62 {NULL, NULL} /* sentinel */
63 };
64
65 static PyObject *
Xxo_getattro(XxoObject * self,PyObject * name)66 Xxo_getattro(XxoObject *self, PyObject *name)
67 {
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;
73 }
74 }
75 return PyObject_GenericGetAttr((PyObject *)self, name);
76 }
77
78 static int
Xxo_setattr(XxoObject * self,const char * name,PyObject * v)79 Xxo_setattr(XxoObject *self, const 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
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*/
141 };
142 /* --------------------------------------------------------------------- */
143
144 /* Function of two integers returning integer */
145
146 PyDoc_STRVAR(xx_foo_doc,
147 "foo(i,j)\n\
148 \n\
149 Return the sum of i and j.");
150
151 static PyObject *
xx_foo(PyObject * self,PyObject * args)152 xx_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 PyLong_FromLong(res);
160 }
161
162
163 /* Function of no arguments returning new Xxo object */
164
165 static PyObject *
xx_new(PyObject * self,PyObject * args)166 xx_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
180 static PyObject *
xx_bug(PyObject * self,PyObject * args)181 xx_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, PyLong_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
201 static PyObject *
xx_roj(PyObject * self,PyObject * args)202 xx_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
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*/
259 };
260
261 /* ---------- */
262
263 static PyObject *
null_richcompare(PyObject * self,PyObject * other,int op)264 null_richcompare(PyObject *self, PyObject *other, int op)
265 {
266 Py_INCREF(Py_NotImplemented);
267 return Py_NotImplemented;
268 }
269
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 PyType_GenericNew, /*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
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 */
332 };
333
334 PyDoc_STRVAR(module_doc,
335 "This is a template module just for instruction.");
336
337
338 static int
xx_exec(PyObject * m)339 xx_exec(PyObject *m)
340 {
341 /* Slot initialization is subject to the rules of initializing globals.
342 C99 requires the initializers to be "address constants". Function
343 designators like 'PyType_GenericNew', with implicit conversion to
344 a pointer, are valid C99 address constants.
345
346 However, the unary '&' operator applied to a non-static variable
347 like 'PyBaseObject_Type' is not required to produce an address
348 constant. Compilers may support this (gcc does), MSVC does not.
349
350 Both compilers are strictly standard conforming in this particular
351 behavior.
352 */
353 Null_Type.tp_base = &PyBaseObject_Type;
354 Str_Type.tp_base = &PyUnicode_Type;
355
356 /* Finalize the type object including setting type of the new type
357 * object; doing it here is required for portability, too. */
358 if (PyType_Ready(&Xxo_Type) < 0)
359 goto fail;
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 goto fail;
366 }
367 Py_INCREF(ErrorObject);
368 PyModule_AddObject(m, "error", ErrorObject);
369
370 /* Add Str */
371 if (PyType_Ready(&Str_Type) < 0)
372 goto fail;
373 PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
374
375 /* Add Null */
376 if (PyType_Ready(&Null_Type) < 0)
377 goto fail;
378 PyModule_AddObject(m, "Null", (PyObject *)&Null_Type);
379 return 0;
380 fail:
381 Py_XDECREF(m);
382 return -1;
383 }
384
385 static struct PyModuleDef_Slot xx_slots[] = {
386 {Py_mod_exec, xx_exec},
387 {0, NULL},
388 };
389
390 static struct PyModuleDef xxmodule = {
391 PyModuleDef_HEAD_INIT,
392 "xx",
393 module_doc,
394 0,
395 xx_methods,
396 xx_slots,
397 NULL,
398 NULL,
399 NULL
400 };
401
402 /* Export function for the module (*must* be called PyInit_xx) */
403
404 PyMODINIT_FUNC
PyInit_xx(void)405 PyInit_xx(void)
406 {
407 return PyModuleDef_Init(&xxmodule);
408 }
409