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)      (Py_TYPE(v) == &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_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
  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         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 *
 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 *
 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 *
 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 *
 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 *
 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         0, /* see PyInit_xx */  /*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 /* Initialization function for the module (*must* be called PyInit_xx) */
 338
 339
 340 static struct PyModuleDef xxmodule = {
 341         PyModuleDef_HEAD_INIT,
 342         "xx",
 343         module_doc,
 344         -1,
 345         xx_methods,
 346         NULL,
 347         NULL,
 348         NULL,
 349         NULL
 350 };
 351
 352 PyMODINIT_FUNC
 353 PyInit_xx(void)
 354 {
 355         PyObject *m = NULL;
 356
 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;
 363
 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;
 368
 369         /* Create the module and add the functions */
 370         m = PyModule_Create(&xxmodule);
 371         if (m == NULL)
 372                 goto fail;
 373
 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;
 379         }
 380         Py_INCREF(ErrorObject);
 381         PyModule_AddObject(m, "error", ErrorObject);
 382
 383         /* Add Str */
 384         if (PyType_Ready(&Str_Type) < 0)
 385                 goto fail;
 386         PyModule_AddObject(m, "Str", (PyObject *)&Str_Type);
 387
 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;
 396 }