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 staticforward 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         {NULL,          NULL}           /* sentinel */
  62 };
  63
  64 static PyObject *
  65 Xxo_getattr(XxoObject *self, char *name)
  66 {
  67         if (self->x_attr != NULL) {
  68                 PyObject *v = PyDict_GetItemString(self->x_attr, name);
  69                 if (v != NULL) {
  70                         Py_INCREF(v);
  71                         return v;
  72                 }
  73         }
  74         return Py_FindMethod(Xxo_methods, (PyObject *)self, name);
  75 }
  76
  77 static int
  78 Xxo_setattr(XxoObject *self, char *name, PyObject *v)
  79 {
  80         if (self->x_attr == NULL) {
  81                 self->x_attr = PyDict_New();
  82                 if (self->x_attr == NULL)
  83                         return -1;
  84         }
  85         if (v == NULL) {
  86                 int rv = PyDict_DelItemString(self->x_attr, name);
  87                 if (rv < 0)
  88                         PyErr_SetString(PyExc_AttributeError,
  89                                 "delete non-existing Xxo attribute");
  90                 return rv;
  91         }
  92         else
  93                 return PyDict_SetItemString(self->x_attr, name, v);
  94 }
  95
  96 statichere PyTypeObject Xxo_Type = {
  97         /* The ob_type field must be initialized in the module init function
  98          * to be portable to Windows without using C++. */
  99         PyObject_HEAD_INIT(NULL)
 100         0,                      /*ob_size*/
 101         "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 };
 116 /* --------------------------------------------------------------------- */
 117
 118 /* Function of two integers returning integer */
 119
 120 static PyObject *
 121 xx_foo(PyObject *self, PyObject *args)
 122 {
 123         long i, j;
 124         long res;
 125         if (!PyArg_ParseTuple(args, "ll:foo", &i, &j))
 126                 return NULL;
 127         res = i+j; /* XXX Do something here */
 128         return PyInt_FromLong(res);
 129 }
 130
 131
 132 /* Function of no arguments returning new Xxo object */
 133
 134 static PyObject *
 135 xx_new(PyObject *self, PyObject *args)
 136 {
 137         XxoObject *rv;
 138
 139         if (!PyArg_ParseTuple(args, ":new"))
 140                 return NULL;
 141         rv = newXxoObject(args);
 142         if ( rv == NULL )
 143             return NULL;
 144         return (PyObject *)rv;
 145 }
 146
 147 /* Example with subtle bug from extensions manual ("Thin Ice"). */
 148
 149 static PyObject *
 150 xx_bug(PyObject *self, PyObject *args)
 151 {
 152         PyObject *list, *item;
 153
 154         if (!PyArg_ParseTuple(args, "O:bug", &list))
 155                 return NULL;
 156
 157         item = PyList_GetItem(list, 0);
 158         /* Py_INCREF(item); */
 159         PyList_SetItem(list, 1, PyInt_FromLong(0L));
 160         PyObject_Print(item, stdout, 0);
 161         printf("\n");
 162         /* Py_DECREF(item); */
 163
 164         Py_INCREF(Py_None);
 165         return Py_None;
 166 }
 167
 168 /* Test bad format character */
 169
 170 static PyObject *
 171 xx_roj(PyObject *self, PyObject *args)
 172 {
 173         PyObject *a;
 174         long b;
 175         if (!PyArg_ParseTuple(args, "O#:roj", &a, &b))
 176                 return NULL;
 177         Py_INCREF(Py_None);
 178         return Py_None;
 179 }
 180
 181
 182 /* List of functions defined in the module */
 183
 184 static PyMethodDef xx_methods[] = {
 185         {"roj",         xx_roj,         METH_VARARGS},
 186         {"foo",         xx_foo,         METH_VARARGS},
 187         {"new",         xx_new,         METH_VARARGS},
 188         {"bug",         xx_bug,         METH_VARARGS},
 189         {NULL,          NULL}           /* sentinel */
 190 };
 191
 192
 193 /* Initialization function for the module (*must* be called initxx) */
 194
 195 DL_EXPORT(void)
 196 initxx(void)
 197 {
 198         PyObject *m, *d;
 199
 200         /* Initialize the type of the new type object here; doing it here
 201          * is required for portability to Windows without requiring C++. */
 202         Xxo_Type.ob_type = &PyType_Type;
 203
 204         /* Create the module and add the functions */
 205         m = Py_InitModule("xx", xx_methods);
 206
 207         /* Add some symbolic constants to the module */
 208         d = PyModule_GetDict(m);
 209         ErrorObject = PyErr_NewException("xx.error", NULL, NULL);
 210         PyDict_SetItemString(d, "error", ErrorObject);
 211 }