chiark - git - mdw - catacomb-python/blob - buffer.c

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Reading and writing buffers of stuff
   6  *
   7  * (c) 2005 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of the Python interface to Catacomb.
  13  *
  14  * Catacomb/Python is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Catacomb/Python is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with Catacomb/Python; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Header files ------------------------------------------------------*/
  30
  31 #include "catacomb-python.h"
  32
  33 /*----- Data structures ---------------------------------------------------*/
  34
  35 typedef struct buf_pyobj {
  36   PyObject_HEAD
  37   buf b;
  38   PyObject *sub;
  39 } buf_pyobj;
  40
  41 static PyTypeObject *rbuf_pytype, *wbuf_pytype;
  42 #define RBUF_PYCHECK(o) PyObject_TypeCheck((o), rbuf_pytype)
  43 #define WBUF_PYCHECK(o) PyObject_TypeCheck((o), wbuf_pytype)
  44 #define BUF_B(o) (&((buf_pyobj *)(o))->b)
  45 #define BUF_SUB(o) (((buf_pyobj *)(o))->sub)
  46
  47 /*----- Exceptions --------------------------------------------------------*/
  48
  49 static PyObject *buferr;
  50
  51 #define BUFERR() do { PyErr_SetNone(buferr); goto end; } while (0)
  52
  53 /*----- Read buffers ------------------------------------------------------*/
  54
  55 static PyObject *rbuf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
  56 {
  57   char *p, *q;
  58   int n;
  59   buf_pyobj *me = 0;
  60   static char *kwlist[] = { "data", 0 };
  61
  62   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &p, &n))
  63     goto end;
  64   q = xmalloc(n);
  65   memcpy(q, p, n);
  66   me = (buf_pyobj *)ty->tp_alloc(ty, 0);
  67   me->sub = 0;
  68   buf_init(&me->b, q, n);
  69 end:
  70   return ((PyObject *)me);
  71 }
  72
  73 static void buf_pydealloc(PyObject *me)
  74 {
  75   if (BUF_SUB(me))
  76     Py_DECREF(BUF_SUB(me));
  77   else
  78     xfree(BBASE(BUF_B(me)));
  79   FREEOBJ(me);
  80 }
  81
  82 static int rbuf_pysegcount(PyObject *me, int *nn)
  83   { if (nn) *nn = BSZ(BUF_B(me)); return (1); }
  84
  85 static int rbuf_pyreadbuf(PyObject *me, int seg, void **q)
  86   { assert(seg == 0); *q = BCUR(BUF_B(me)); return (BLEFT(BUF_B(me))); }
  87
  88 static PyObject *rbmeth_skip(PyObject *me, PyObject *arg)
  89 {
  90   size_t n;
  91
  92   if (!PyArg_ParseTuple(arg, "O&:skip", convszt, &n)) goto end;
  93   if (!buf_get(BUF_B(me), n)) BUFERR();
  94   RETURN_ME;
  95 end:
  96   return (0);
  97 }
  98
  99 static PyObject *rbmeth_get(PyObject *me, PyObject *arg)
 100 {
 101   void *p;
 102   size_t n;
 103
 104   if (!PyArg_ParseTuple(arg, "O&:get", convszt, &n)) goto end;
 105   if ((p = buf_get(BUF_B(me), n)) == 0) BUFERR();
 106   return (bytestring_pywrap(p, n));
 107 end:
 108   return (0);
 109 }
 110
 111 #define RBMETH_GETU_(n, W, w)                                           \
 112   static PyObject *rbmeth_getu##w(PyObject *me, PyObject *arg)          \
 113   {                                                                     \
 114     uint##n x;                                                          \
 115     if (!PyArg_ParseTuple(arg, ":getu" #w)) goto end;                   \
 116     if (buf_getu##w(BUF_B(me), &x)) BUFERR();                           \
 117     return (getu32(x));                                                 \
 118   end:                                                                  \
 119     return (0);                                                         \
 120   }
 121 DOUINTCONV(RBMETH_GETU_)
 122
 123 #define RBMETH_GETBLK_(n, W, w)                                         \
 124   static PyObject *rbmeth_getblk##w(PyObject *me, PyObject *arg)        \
 125   {                                                                     \
 126     size_t sz;                                                          \
 127     char *q;                                                            \
 128     if (!PyArg_ParseTuple(arg, ":getblk" #w)) goto end;                 \
 129     if ((q = buf_getmem##w(BUF_B(me), &sz)) == 0) BUFERR();             \
 130     return (bytestring_pywrap(q, sz));                                  \
 131   end:                                                                  \
 132     return (0);                                                         \
 133   }
 134 BUF_DOSUFFIXES(RBMETH_GETBLK_)
 135
 136 #define RBMETH_GETBUF_(n, W, w)                                         \
 137   static PyObject *rbmeth_getbuf##w(PyObject *me, PyObject *arg)        \
 138   {                                                                     \
 139     buf_pyobj *b;                                                       \
 140     buf bb;                                                             \
 141     if (!PyArg_ParseTuple(arg, ":getbuf" #w)) goto end;                 \
 142     if (buf_getbuf##w(BUF_B(me), &bb)) BUFERR();                        \
 143     b = PyObject_NEW(buf_pyobj, rbuf_pytype);                           \
 144     b->b = bb;                                                          \
 145     b->sub = me;                                                        \
 146     Py_INCREF(me);                                                      \
 147     return ((PyObject *)b);                                             \
 148   end:                                                                  \
 149     return (0);                                                         \
 150   }
 151 BUF_DOSUFFIXES(RBMETH_GETBUF_)
 152
 153 static PyObject *rbmeth_getmp(PyObject *me, PyObject *arg)
 154 {
 155   mp *x;
 156   if (!PyArg_ParseTuple(arg, ":getmp")) goto end;
 157   if ((x = buf_getmp(BUF_B(me))) == 0) BUFERR();
 158   return (mp_pywrap(x));
 159 end:
 160   return (0);
 161 }
 162
 163 static PyObject *rbmeth_getgf(PyObject *me, PyObject *arg)
 164 {
 165   mp *x;
 166   if (!PyArg_ParseTuple(arg, ":getgf")) goto end;
 167   if ((x = buf_getmp(BUF_B(me))) == 0) BUFERR();
 168   return (gf_pywrap(x));
 169 end:
 170   return (0);
 171 }
 172
 173 static PyObject *rbmeth_getecpt(PyObject *me, PyObject *arg, PyObject *kw)
 174 {
 175   PyObject *cobj = Py_None;
 176   static char *kwlist[] = { "curve", 0 };
 177   ec pt = EC_INIT;
 178   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:getecpt", kwlist, &cobj))
 179     goto end;
 180   if (cobj == Py_None) cobj = (PyObject *)ecpt_pytype;
 181   if (!PyType_Check(cobj) ||
 182       !PyType_IsSubtype((PyTypeObject *)cobj, ecpt_pytype))
 183     TYERR("expected elliptic curve type");
 184   if (buf_getec(BUF_B(me), &pt)) BUFERR();
 185   return (ecpt_pywrapout(cobj, &pt));
 186 end:
 187   return (0);
 188 }
 189
 190 static PyObject *rbmeth_getecptraw(PyObject *me, PyObject *arg)
 191 {
 192   PyTypeObject *cobj = ecpt_pytype;
 193   ec pt = EC_INIT;
 194   if (!PyArg_ParseTuple(arg, "O!:getecptraw", eccurve_pytype, &cobj))
 195     goto end;
 196   if (ec_getraw(ECCURVE_C(cobj), BUF_B(me), &pt)) BUFERR();
 197   return (ecpt_pywrapout(cobj, &pt));
 198 end:
 199   return (0);
 200 }
 201
 202 static PyObject *rbmeth_getge(PyObject *me, PyObject *arg)
 203 {
 204   PyObject *gobj;
 205   ge *x = 0;
 206   if (!PyArg_ParseTuple(arg, "O!:getge", group_pytype, &gobj)) goto end;
 207   x = G_CREATE(GROUP_G(gobj));
 208   if (G_FROMBUF(GROUP_G(gobj), BUF_B(me), x)) BUFERR();
 209   return (ge_pywrap(gobj, x));
 210 end:
 211   if (x) G_DESTROY(GROUP_G(gobj), x);
 212   return (0);
 213 }
 214
 215 static PyObject *rbmeth_getgeraw(PyObject *me, PyObject *arg)
 216 {
 217   PyObject *gobj;
 218   ge *x = 0;
 219   if (!PyArg_ParseTuple(arg, "O!:getgeraw", group_pytype, &gobj)) goto end;
 220   x = G_CREATE(GROUP_G(gobj));
 221   if (G_FROMRAW(GROUP_G(gobj), BUF_B(me), x)) BUFERR();
 222   return (ge_pywrap(gobj, x));
 223 end:
 224   if (x) G_DESTROY(GROUP_G(gobj), x);
 225   return (0);
 226 }
 227
 228 static PyObject *rbget_size(PyObject *me, void *hunoz)
 229   { return (PyInt_FromLong(BSZ(BUF_B(me)))); }
 230 static PyObject *rbget_left(PyObject *me, void *hunoz)
 231   { return (PyInt_FromLong(BLEFT(BUF_B(me)))); }
 232 static PyObject *rbget_endp(PyObject *me, void *hunoz)
 233   { return (getbool(!BLEFT(BUF_B(me)))); }
 234 static PyObject *rbget_offset(PyObject *me, void *hunoz)
 235   { return (PyInt_FromLong(BLEN(BUF_B(me)))); }
 236 static int rbset_offset(PyObject *me, PyObject *x, void *hunoz)
 237 {
 238   size_t n;
 239   if (!x) NIERR("__del__");
 240   if (!convszt(x, &n)) goto end;
 241   if (n > BSZ(BUF_B(me))) VALERR("out of range");
 242   BCUR(BUF_B(me)) = BBASE(BUF_B(me)) + n;
 243   return (0);
 244 end:
 245   return (-1);
 246 }
 247
 248 static PyGetSetDef rbuf_pygetset[] = {
 249 #define GETSETNAME(op, name) rb##op##_##name
 250   GET   (size,                  "RBUF.size -> SIZE")
 251   GET   (left,                  "RBUF.left -> REMAINDER")
 252   GET   (endp,                  "RBUF.endp -> BOOL")
 253   GETSET(offset,                "RBUF.offset -> OFFSET")
 254 #undef GETSETNAME
 255   { 0 }
 256 };
 257
 258 static PyMethodDef rbuf_pymethods[] = {
 259 #define METHNAME(func) rbmeth_##func
 260   METH  (skip,                  "RBUF.skip(N)")
 261   METH  (get,                   "RBUF.get(N) -> BYTES")
 262 #define RBMETH_DECL_GETU_(n, W, w)                                      \
 263     METH(getu##w, "RBUF.getu" #w "() -> INT")
 264   DOUINTCONV(RBMETH_DECL_GETU_)
 265 #define RBMETH_DECL_GETBLK_(n, W, w)                                    \
 266     METH(getblk##w, "RBUF.getblk" #w "() -> INT")
 267   BUF_DOSUFFIXES(RBMETH_DECL_GETBLK_)
 268 #define RBMETH_DECL_GETBUF_(n, W, w)                                    \
 269     METH(getbuf##w, "RBUF.getbuf" #w "() -> INT")
 270   BUF_DOSUFFIXES(RBMETH_DECL_GETBUF_)
 271   METH  (getmp,                 "RBUF.getmp() -> X")
 272   METH  (getgf,                 "RBUF.getgf() -> X")
 273   KWMETH(getecpt,               "RBUF.getecpt(curve = None) -> P")
 274   METH  (getecptraw,            "RBUF.getecptraw(CURVE) -> P")
 275   METH  (getge,                 "RBUF.getge(GROUP) -> X")
 276   METH  (getgeraw,              "RBUF.getgeraw(GROUP) -> X")
 277 #undef METHNAME
 278   { 0 }
 279 };
 280
 281 static PyBufferProcs rbuf_pybuffer = {
 282   rbuf_pyreadbuf,                       /* @bf_getreadbuffer@ */
 283   0,                                    /* @bf_getwritebuffer@ */
 284   rbuf_pysegcount,                      /* @bf_getsegcount@ */
 285   0                                     /* @bf_getcharbuffer@ */
 286 };
 287
 288 static PyTypeObject rbuf_pytype_skel = {
 289   PyObject_HEAD_INIT(0) 0,              /* Header */
 290   "catacomb.ReadBuffer",                /* @tp_name@ */
 291   sizeof(buf_pyobj),                    /* @tp_basicsize@ */
 292   0,                                    /* @tp_itemsize@ */
 293
 294   buf_pydealloc,                        /* @tp_dealloc@ */
 295   0,                                    /* @tp_print@ */
 296   0,                                    /* @tp_getattr@ */
 297   0,                                    /* @tp_setattr@ */
 298   0,                                    /* @tp_compare@ */
 299   0,                                    /* @tp_repr@ */
 300   0,                                    /* @tp_as_number@ */
 301   0,                                    /* @tp_as_sequence@ */
 302   0,                                    /* @tp_as_mapping@ */
 303   0,                                    /* @tp_hash@ */
 304   0,                                    /* @tp_call@ */
 305   0,                                    /* @tp_str@ */
 306   0,                                    /* @tp_getattro@ */
 307   0,                                    /* @tp_setattro@ */
 308   &rbuf_pybuffer,                       /* @tp_as_buffer@ */
 309   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 310     Py_TPFLAGS_BASETYPE,
 311
 312   /* @tp_doc@ */
 313   "A read buffer.",
 314
 315   0,                                    /* @tp_traverse@ */
 316   0,                                    /* @tp_clear@ */
 317   0,                                    /* @tp_richcompare@ */
 318   0,                                    /* @tp_weaklistoffset@ */
 319   0,                                    /* @tp_iter@ */
 320   0,                                    /* @tp_iternext@ */
 321   rbuf_pymethods,                       /* @tp_methods@ */
 322   0,                                    /* @tp_members@ */
 323   rbuf_pygetset,                        /* @tp_getset@ */
 324   0,                                    /* @tp_base@ */
 325   0,                                    /* @tp_dict@ */
 326   0,                                    /* @tp_descr_get@ */
 327   0,                                    /* @tp_descr_set@ */
 328   0,                                    /* @tp_dictoffset@ */
 329   0,                                    /* @tp_init@ */
 330   PyType_GenericAlloc,                  /* @tp_alloc@ */
 331   rbuf_pynew,                           /* @tp_new@ */
 332   0,                                    /* @tp_free@ */
 333   0                                     /* @tp_is_gc@ */
 334 };
 335
 336 /*----- Write buffers -----------------------------------------------------*/
 337
 338 static void ensure(PyObject *me, size_t n)
 339 {
 340   buf *b = BUF_B(me);
 341
 342   if (BLEFT(b) < n) {
 343     size_t nn = BSZ(b);
 344     octet *p;
 345     size_t want = BLEFT(b) + n;
 346     while (nn < want) nn <<= 1;
 347     p = xrealloc(BBASE(b), nn, BSZ(b));
 348     BCUR(b) = p + BLEN(b);
 349     BLIM(b) = p + nn;
 350     BBASE(b) = p;
 351   }
 352 }
 353
 354 static PyObject *wbuf_pynew(PyTypeObject *ty, PyObject *arg, PyObject *kw)
 355 {
 356   char *p;
 357   size_t n = 64;
 358   buf_pyobj *me = 0;
 359   static char *kwlist[] = { "size", 0 };
 360
 361   if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:new", kwlist,
 362                                    convszt, &n))
 363     goto end;
 364   me = (buf_pyobj *)ty->tp_alloc(ty, 0);
 365   p = xmalloc(n);
 366   me->sub = 0;
 367   buf_init(&me->b, p, n);
 368 end:
 369   return ((PyObject *)me);
 370 }
 371
 372 static int wbuf_pysegcount(PyObject *me, int *nn)
 373   { if (nn) *nn = BLEN(BUF_B(me)); return (1); }
 374
 375 static int wbuf_pyreadbuf(PyObject *me, int seg, void **q)
 376   { assert(seg == 0); *q = BBASE(BUF_B(me)); return (BLEN(BUF_B(me))); }
 377
 378 static PyObject *wbmeth_zero(PyObject *me, PyObject *arg)
 379 {
 380   void *p;
 381   size_t n;
 382   if (!PyArg_ParseTuple(arg, "O&:zero", convszt, &n)) return (0);
 383   ensure(me, n);
 384   p = buf_get(BUF_B(me), n); assert(p && BOK(BUF_B(me)));
 385   memset(p, 0, n);
 386   RETURN_ME;
 387 }
 388
 389 static PyObject *wbmeth_put(PyObject *me, PyObject *arg)
 390 {
 391   void *p;
 392   int n;
 393   if (!PyArg_ParseTuple(arg, "s#:put", &p, &n)) return (0);
 394   ensure(me, n);
 395   buf_put(BUF_B(me), p, n); assert(BOK(BUF_B(m)));
 396   RETURN_ME;
 397 }
 398
 399 #define WBMETH_PUTU_(n, W, w)                                           \
 400   static PyObject *wbmeth_putu##w(PyObject *me, PyObject *arg)          \
 401   {                                                                     \
 402     uint##n i;                                                          \
 403     if (!PyArg_ParseTuple(arg, "O&:putu" #w, convu##n, &i)) return (0); \
 404     ensure(me, SZ_##n);                                                 \
 405     buf_putu##w(BUF_B(me), i); assert(BOK(BUF_B(me)));                  \
 406     RETURN_ME;                                                          \
 407   }
 408 DOUINTCONV(WBMETH_PUTU_)
 409
 410 #define SZ_z 1
 411 #define WBMETH_PUTBLK_(n, W, w)                                         \
 412   static PyObject *wbmeth_putblk##w(PyObject *me, PyObject *arg)        \
 413   {                                                                     \
 414     char *p;                                                            \
 415     int sz;                                                             \
 416     if (!PyArg_ParseTuple(arg, "s#:putblk" #w, &p, &sz)) return (0);    \
 417     ensure(me, sz + SZ_##n);                                            \
 418     buf_putmem##w(BUF_B(me), p, sz); assert(BOK(BUF_B(me)));            \
 419     RETURN_ME;                                                          \
 420   }
 421 BUF_DOSUFFIXES(WBMETH_PUTBLK_)
 422
 423 static PyObject *wbmeth_putmp(PyObject *me, PyObject *arg)
 424 {
 425   mp *x = 0;
 426   if (!PyArg_ParseTuple(arg, "O&:putmp", convmp, &x)) return (0);
 427   ensure(me, mp_octets(x) + 2);
 428   buf_putmp(BUF_B(me), x); assert(BOK(BUF_B(me)));
 429   RETURN_ME;
 430 }
 431
 432 static PyObject *wbmeth_putgf(PyObject *me, PyObject *arg)
 433 {
 434   mp *x = 0;
 435   if (!PyArg_ParseTuple(arg, "O&:putgf", convgf, &x)) return (0);
 436   ensure(me, mp_octets(x) + 2);
 437   buf_putmp(BUF_B(me), x); assert(BOK(BUF_B(me)));
 438   MP_DROP(x);
 439   RETURN_ME;
 440 }
 441
 442 static PyObject *wbmeth_putecpt(PyObject *me, PyObject *arg)
 443 {
 444   ec pt = EC_INIT;
 445   if (!PyArg_ParseTuple(arg, "O&:putecpt", convecpt, &pt)) return (0);
 446   if (EC_ATINF(&pt)) ensure(me, 2);
 447   else ensure(me, 4 + mp_octets(pt.x) + mp_octets(pt.y));
 448   buf_putec(BUF_B(me), &pt); assert(BOK(BUF_B(me)));
 449   EC_DESTROY(&pt);
 450   RETURN_ME;
 451 }
 452
 453 static PyObject *wbmeth_putecptraw(PyObject *me, PyObject *arg)
 454 {
 455   PyObject *ptobj;
 456   ec pt = EC_INIT;
 457   if (!PyArg_ParseTuple(arg, "O!:putecptraw", ecptcurve_pytype, &ptobj))
 458     return (0);
 459   EC_OUT(ECPT_C(ptobj), &pt, ECPT_P(ptobj));
 460   ensure(me, ECPT_C(ptobj)->f->noctets * 2 + 1);
 461   ec_putraw(ECPT_C(ptobj), BUF_B(me), &pt); assert(BOK(BUF_B(me)));
 462   EC_DESTROY(&pt);
 463   RETURN_ME;
 464 }
 465
 466 static PyObject *wbmeth_putge(PyObject *me, PyObject *arg)
 467 {
 468   PyObject *geobj;
 469   if (!PyArg_ParseTuple(arg, "O!:putge", ge_pytype, &geobj)) return (0);
 470   ensure(me, GE_G(geobj)->noctets);
 471   G_TOBUF(GE_G(geobj), BUF_B(me), GE_X(geobj)); assert(BOK(BUF_B(me)));
 472   RETURN_ME;
 473 }
 474
 475 static PyObject *wbmeth_putgeraw(PyObject *me, PyObject *arg)
 476 {
 477   PyObject *geobj;
 478   if (!PyArg_ParseTuple(arg, "O!:putgeraw", ge_pytype, &geobj)) return (0);
 479   ensure(me, GE_G(geobj)->noctets);
 480   G_TORAW(GE_G(geobj), BUF_B(me), GE_X(geobj)); assert(BOK(BUF_B(me)));
 481   RETURN_ME;
 482 }
 483
 484 static PyObject *wbget_size(PyObject *me, void *hunoz)
 485   { return (PyInt_FromLong(BLEN(BUF_B(me)))); }
 486
 487 static PyGetSetDef wbuf_pygetset[] = {
 488 #define GETSETNAME(op, name) wb##op##_##name
 489   GET   (size,                  "WBUF.size -> SIZE")
 490 #undef GETSETNAME
 491   { 0 }
 492 };
 493
 494 static PyMethodDef wbuf_pymethods[] = {
 495 #define METHNAME(func) wbmeth_##func
 496   METH  (zero,                  "WBUF.skip(N)")
 497   METH  (put,                   "WBUF.put(BYTES)")
 498 #define WBMETH_DECL_PUTU_(n, W, w)                                      \
 499     METH(putu##w, "WBUF.putu" #w "(INT)")
 500   DOUINTCONV(WBMETH_DECL_PUTU_)
 501 #define WBMETH_DECL_PUTBLK_(n, W, w)                                    \
 502     METH(putblk##w, "WBUF.putblk" #w "(BYTES)")
 503   BUF_DOSUFFIXES(WBMETH_DECL_PUTBLK_)
 504   METH  (putmp,                 "WBUF.putmp(X)")
 505   METH  (putgf,                 "WBUF.putgf(X)")
 506   KWMETH(putecpt,               "WBUF.putecpt(P)")
 507   METH  (putecptraw,            "WBUF.putecptraw(P)")
 508   METH  (putge,                 "WBUF.putge(X)")
 509   METH  (putgeraw,              "WBUF.putgeraw(X)")
 510 #undef METHNAME
 511   { 0 }
 512 };
 513
 514 static PyBufferProcs wbuf_pybuffer = {
 515   wbuf_pyreadbuf,                       /* @bf_getreadbuffer@ */
 516   0,                                    /* @bf_getwritebuffer@ */
 517   wbuf_pysegcount,                      /* @bf_getsegcount@ */
 518   0                                     /* @bf_getcharbuffer@ */
 519 };
 520
 521 static PyTypeObject wbuf_pytype_skel = {
 522   PyObject_HEAD_INIT(0) 0,              /* Header */
 523   "catacomb.WriteBuffer",               /* @tp_name@ */
 524   sizeof(buf_pyobj),                    /* @tp_basicsize@ */
 525   0,                                    /* @tp_itemsize@ */
 526
 527   buf_pydealloc,                        /* @tp_dealloc@ */
 528   0,                                    /* @tp_print@ */
 529   0,                                    /* @tp_getattr@ */
 530   0,                                    /* @tp_setattr@ */
 531   0,                                    /* @tp_compare@ */
 532   0,                                    /* @tp_repr@ */
 533   0,                                    /* @tp_as_number@ */
 534   0,                                    /* @tp_as_sequence@ */
 535   0,                                    /* @tp_as_mapping@ */
 536   0,                                    /* @tp_hash@ */
 537   0,                                    /* @tp_call@ */
 538   0,                                    /* @tp_str@ */
 539   0,                                    /* @tp_getattro@ */
 540   0,                                    /* @tp_setattro@ */
 541   &wbuf_pybuffer,                       /* @tp_as_buffer@ */
 542   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 543     Py_TPFLAGS_BASETYPE,
 544
 545   /* @tp_doc@ */
 546   "A write buffer.",
 547
 548   0,                                    /* @tp_traverse@ */
 549   0,                                    /* @tp_clear@ */
 550   0,                                    /* @tp_richcompare@ */
 551   0,                                    /* @tp_weaklistoffset@ */
 552   0,                                    /* @tp_iter@ */
 553   0,                                    /* @tp_iternext@ */
 554   wbuf_pymethods,                       /* @tp_methods@ */
 555   0,                                    /* @tp_members@ */
 556   wbuf_pygetset,                        /* @tp_getset@ */
 557   0,                                    /* @tp_base@ */
 558   0,                                    /* @tp_dict@ */
 559   0,                                    /* @tp_descr_get@ */
 560   0,                                    /* @tp_descr_set@ */
 561   0,                                    /* @tp_dictoffset@ */
 562   0,                                    /* @tp_init@ */
 563   PyType_GenericAlloc,                  /* @tp_alloc@ */
 564   wbuf_pynew,                           /* @tp_new@ */
 565   0,                                    /* @tp_free@ */
 566   0                                     /* @tp_is_gc@ */
 567 };
 568
 569 /*----- Initialization ----------------------------------------------------*/
 570
 571 void buffer_pyinit(void)
 572 {
 573   INITTYPE(rbuf, root);
 574   INITTYPE(wbuf, root);
 575 }
 576
 577 void buffer_pyinsert(PyObject *mod)
 578 {
 579   INSEXC("BufferError", buferr, PyExc_Exception, 0);
 580   INSERT("ReadBuffer", rbuf_pytype);
 581   INSERT("WriteBuffer", wbuf_pytype);
 582 }
 583
 584 /*----- That's all, folks -------------------------------------------------*/