Modules/xxmodule.c

   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
  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)      ((v)->ob_type == &Xxo_Type)
  29
  30 static XxoObject *
  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
  44 Xxo_dealloc(XxoObject *self)
  45 {
  46         Py_XDECREF(self->x_attr);
  47         PyObject_Del(self);
  48 }
  49
  50 static PyObject *
  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 *
  66 Xxo_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
  78 static int
  79 Xxo_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
  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         PyObject_HEAD_INIT(NULL)
 101         0,                      /*ob_size*/
 102         "xxmodule.Xxo",         /*tp_name*/
 103         sizeof(XxoObject),      /*tp_basicsize*/
 104         0,                      /*tp_itemsize*/
 105         /* methods */
 106         (destructor)Xxo_dealloc, /*tp_dealloc*/
 107         0,                      /*tp_print*/
 108         (getattrfunc)Xxo_getattr, /*tp_getattr*/
 109         (setattrfunc)Xxo_setattr, /*tp_setattr*/
 110         0,                      /*tp_compare*/
 111         0,                      /*tp_repr*/
 112         0,                      /*tp_as_number*/
 113         0,                      /*tp_as_sequence*/
 114         0,                      /*tp_as_mapping*/
 115         0,                      /*tp_hash*/
 116         0,                      /*tp_call*/
 117         0,                      /*tp_str*/
 118         0,                      /*tp_getattro*/
 119         0,                      /*tp_setattro*/
 120         0,                      /*tp_as_buffer*/
 121         Py_TPFLAGS_DEFAULT,     /*tp_flags*/
 122         0,                      /*tp_doc*/
 123         0,                      /*tp_traverse*/
 124         0,                      /*tp_clear*/
 125         0,                      /*tp_richcompare*/
 126         0,                      /*tp_weaklistoffset*/
 127         0,                      /*tp_iter*/
 128         0,                      /*tp_iternext*/
 129         0,                      /*tp_methods*/
 130         0,                      /*tp_members*/
 131         0,                      /*tp_getset*/
 132         0,                      /*tp_base*/
 133         0,                      /*tp_dict*/
 134         0,                      /*tp_descr_get*/
 135         0,                      /*tp_descr_set*/
 136         0,                      /*tp_dictoffset*/
 137         0,                      /*tp_init*/
 138         0,                      /*tp_alloc*/
 139         0,                      /*tp_new*/
 140         0,                      /*tp_free*/
 141         0,                      /*tp_is_gc*/
 142 };
 143 /* --------------------------------------------------------------------- */
 144
 145 /* Function of two integers returning integer */
 146
 147 PyDoc_STRVAR(xx_foo_doc,
 148 "foo(i,j)\n\
 149 \n\
 150 Return the sum of i and j.");
 151
 152 static PyObject *
 153 xx_foo(PyObject *self, PyObject *args)
 154 {
 155         long i, j;
 156         long res;
 157         if (!PyArg_ParseTuple(args, "ll:foo", &i, &j))
 158                 return NULL;
 159         res = i+j; /* XXX Do something here */
 160         return PyInt_FromLong(res);
 161 }
 162
 163
 164 /* Function of no arguments returning new Xxo object */
 165
 166 static PyObject *
 167 xx_new(PyObject *self, PyObject *args)
 168 {
 169         XxoObject *rv;
 170
 171         if (!PyArg_ParseTuple(args, ":new"))
 172                 return NULL;
 173         rv = newXxoObject(args);
 174         if (rv == NULL)
 175                 return NULL;
 176         return (PyObject *)rv;
 177 }
 178
 179 /* Example with subtle bug from extensions manual ("Thin Ice"). */
 180
 181 static PyObject *
 182 xx_bug(PyObject *self, PyObject *args)
 183 {
 184         PyObject *list, *item;
 185
 186         if (!PyArg_ParseTuple(args, "O:bug", &list))
 187                 return NULL;
 188
 189         item = PyList_GetItem(list, 0);
 190         /* Py_INCREF(item); */
 191         PyList_SetItem(list, 1, PyInt_FromLong(0L));
 192         PyObject_Print(item, stdout, 0);
 193         printf("\n");
 194         /* Py_DECREF(item); */
 195
 196         Py_INCREF(Py_None);
 197         return Py_None;
 198 }
 199
 200 /* Test bad format character */
 201
 202 static PyObject *
 203 xx_roj(PyObject *self, PyObject *args)
 204 {
 205         PyObject *a;
 206         long b;
 207         if (!PyArg_ParseTuple(args, "O#:roj", &a, &b))
 208                 return NULL;
 209         Py_INCREF(Py_None);
 210         return Py_None;
 211 }
 212
 213
 214 /* ---------- */
 215
 216 static PyTypeObject Str_Type = {
 217         /* The ob_type field must be initialized in the module init function
 218          * to be portable to Windows without using C++. */
 219         PyObject_HEAD_INIT(NULL)
 220         0,                      /*ob_size*/
 221         "xxmodule.Str",         /*tp_name*/
 222         0,                      /*tp_basicsize*/
 223         0,                      /*tp_itemsize*/
 224         /* methods */
 225         0,                      /*tp_dealloc*/
 226         0,                      /*tp_print*/
 227         0,                      /*tp_getattr*/
 228         0,                      /*tp_setattr*/
 229         0,                      /*tp_compare*/
 230         0,                      /*tp_repr*/
 231         0,                      /*tp_as_number*/
 232         0,                      /*tp_as_sequence*/
 233         0,                      /*tp_as_mapping*/
 234         0,                      /*tp_hash*/
 235         0,                      /*tp_call*/
 236         0,                      /*tp_str*/
 237         0,                      /*tp_getattro*/
 238         0,                      /*tp_setattro*/
 239         0,                      /*tp_as_buffer*/
 240         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 241         0,                      /*tp_doc*/
 242         0,                      /*tp_traverse*/
 243         0,                      /*tp_clear*/
 244         0,                      /*tp_richcompare*/
 245         0,                      /*tp_weaklistoffset*/
 246         0,                      /*tp_iter*/
 247         0,                      /*tp_iternext*/
 248         0,                      /*tp_methods*/
 249         0,                      /*tp_members*/
 250         0,                      /*tp_getset*/
 251         &PyString_Type,         /*tp_base*/
 252         0,                      /*tp_dict*/
 253         0,                      /*tp_descr_get*/
 254         0,                      /*tp_descr_set*/
 255         0,                      /*tp_dictoffset*/
 256         0,                      /*tp_init*/
 257         0,                      /*tp_alloc*/
 258         0,                      /*tp_new*/
 259         0,                      /*tp_free*/
 260         0,                      /*tp_is_gc*/
 261 };
 262
 263 /* ---------- */
 264
 265 static PyObject *
 266 null_richcompare(PyObject *self, PyObject *other, int op)
 267 {
 268         Py_INCREF(Py_NotImplemented);
 269         return Py_NotImplemented;
 270 }
 271
 272 static PyTypeObject Null_Type = {
 273         /* The ob_type field must be initialized in the module init function
 274          * to be portable to Windows without using C++. */
 275         PyObject_HEAD_INIT(NULL)
 276         0,                      /*ob_size*/
 277         "xxmodule.Null",        /*tp_name*/
 278         0,                      /*tp_basicsize*/
 279         0,                      /*tp_itemsize*/
 280         /* methods */
 281         0,                      /*tp_dealloc*/
 282         0,                      /*tp_print*/
 283         0,                      /*tp_getattr*/
 284         0,                      /*tp_setattr*/
 285         0,                      /*tp_compare*/
 286         0,                      /*tp_repr*/
 287         0,                      /*tp_as_number*/
 288         0,                      /*tp_as_sequence*/
 289         0,                      /*tp_as_mapping*/
 290         0,                      /*tp_hash*/
 291         0,                      /*tp_call*/
 292         0,                      /*tp_str*/
 293         0,                      /*tp_getattro*/
 294         0,                      /*tp_setattro*/
 295         0,                      /*tp_as_buffer*/
 296         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 297         0,                      /*tp_doc*/
 298         0,                      /*tp_traverse*/
 299         0,                      /*tp_clear*/
 300         null_richcompare,       /*tp_richcompare*/
 301         0,                      /*tp_weaklistoffset*/
 302         0,                      /*tp_iter*/
 303         0,                      /*tp_iternext*/
 304         0,                      /*tp_methods*/
 305         0,                      /*tp_members*/
 306         0,                      /*tp_getset*/
 307         &PyBaseObject_Type,     /*tp_base*/
 308         0,                      /*tp_dict*/
 309         0,                      /*tp_descr_get*/
 310         0,                      /*tp_descr_set*/
 311         0,                      /*tp_dictoffset*/
 312         0,                      /*tp_init*/
 313         0,                      /*tp_alloc*/
 314         PyType_GenericNew,      /*tp_new*/
 315         0,                      /*tp_free*/
 316         0,                      /*tp_is_gc*/
 317 };
 318
 319
 320 /* ---------- */
 321
 322
 323 /* List of functions defined in the module */
 324
 325 static PyMethodDef xx_methods[] = {
 326         {"roj",         xx_roj,         METH_VARARGS,
 327                 PyDoc_STR("roj(a,b) -> None")},
 328         {"foo",         xx_foo,         METH_VARARGS,
 329                 xx_foo_doc},
 330         {"new",         xx_new,         METH_VARARGS,
 331                 PyDoc_STR("new() -> new Xx object")},
 332         {"bug",         xx_bug,         METH_VARARGS,
 333                 PyDoc_STR("bug(o) -> None")},
 334         {NULL,          NULL}           /* sentinel */
 335 };
 336
 337 PyDoc_STRVAR(module_doc,
 338 "This is a template module just for instruction.");
 339
 340 /* Initialization function for the module (*must* be called initxx) */
 341
 342 PyMODINIT_FUNC
 343 initxx(void)
 344 {
 345         PyObject *m;
 346
 347         /* Finalize the type object including setting type of the new type
 348          * object; doing it here is required for portability to Windows
 349          * without requiring C++. */
 350         if (PyType_Ready(&Xxo_Type) < 0)
 351                 return;
 352
 353         /* Create the module and add the functions */
 354         m = Py_InitModule3("xx", xx_methods, module_doc);
 355         if (m == NULL)
 356                 return;
 357
 358         /* Add some symbolic constants to the module */
 359         if (ErrorObject == NULL) {
 360                 ErrorObject = PyErr_NewException("xx.error", NULL, NULL);
 361                 if (ErrorObject == NULL)
 362                         return;
 363         }
 364         Py_INCREF(ErrorObject);
 365         PyModule_AddObject(m, "error", ErrorObject);
 366
 367         /* Add Str */
 368         if (PyType_Ready(&Str_Type) < 0)
 369                 return;
 370         PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
 371
 372         /* Add Null */
 373         if (PyType_Ready(&Null_Type) < 0)
 374                 return;
 375         PyModule_AddObject(m, "Null", (PyObject *)&Null_Type);
 376 }