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

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