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

   1 /* -*-c-*-
   2  *
   3  * Byte strings
   4  *
   5  * (c) 2004 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 /*----- Main code ---------------------------------------------------------*/
  32
  33 PyTypeObject *bytestring_pytype;
  34
  35 static PyObject *empty, *bytev[256];
  36
  37 static PyObject *allocate(PyTypeObject *ty, size_t n)
  38 {
  39   PyStringObject *x;
  40   x = (PyStringObject *)ty->tp_alloc(ty, n);
  41   x->ob_sval[n] = 0;
  42 #if defined(CACHE_HASH) || PY_VERSION_HEX >= 0x02030000
  43   x->ob_shash = -1;
  44 #endif
  45   x->ob_sstate = SSTATE_NOT_INTERNED;
  46   return ((PyObject *)x);
  47 }
  48
  49 static PyObject *dowrap(PyTypeObject *ty, const void *p, size_t n)
  50 {
  51   PyObject *x;
  52   int ch;
  53
  54   if (p && ty == bytestring_pytype) {
  55     if (!n) {
  56       if (!empty) empty = allocate(ty, 0);
  57       Py_INCREF(empty); return (empty);
  58     } else if (n == 1 && (ch = *(unsigned char *)p) < sizeof(bytev)) {
  59       if (!bytev[ch])
  60         { bytev[ch] = allocate(ty, 1); *PyString_AS_STRING(bytev[ch]) = ch; }
  61       Py_INCREF(bytev[ch]); return (bytev[ch]);
  62     }
  63   }
  64
  65   x = allocate(ty, n);
  66   if (p) memcpy(PyString_AS_STRING(x), p, n);
  67   return (x);
  68 }
  69
  70 PyObject *bytestring_pywrap(const void *p, size_t n)
  71   { return (dowrap(bytestring_pytype, p, n)); }
  72
  73 PyObject *bytestring_pywrapbuf(buf *b)
  74   { return (dowrap(bytestring_pytype, BCUR(b), BLEFT(b))); }
  75
  76 static PyObject *bytestring_pynew(PyTypeObject *ty,
  77                                   PyObject *arg, PyObject *kw)
  78 {
  79   const char *p;
  80   Py_ssize_t n;
  81   static const char *const kwlist[] = { "data", 0 };
  82   if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", KWLIST, &p, &n))
  83     return (0);
  84   return (dowrap(ty, p, n));
  85 }
  86
  87 static PyObject *meth_ctstreq(PyObject *me, PyObject *arg)
  88 {
  89   char *p, *q;
  90   Py_ssize_t psz, qsz;
  91   if (!PyArg_ParseTuple(arg, "s#s#:ctstreq", &p, &psz, &q, &qsz))
  92     goto end;
  93   if (psz == qsz && ct_memeq(p, q, psz)) RETURN_TRUE;
  94   else RETURN_FALSE;
  95 end:
  96   return (0);
  97 }
  98
  99 static PyObject *meth__ByteString_zero(PyObject *me, PyObject *arg)
 100 {
 101   size_t sz;
 102   PyObject *rc = 0;
 103   if (!PyArg_ParseTuple(arg, "OO&:zero", &me, convszt, &sz)) goto end;
 104   rc = bytestring_pywrap(0, sz);
 105   memset(PyString_AS_STRING(rc), 0, sz);
 106 end:
 107   return (rc);
 108 }
 109
 110 static PyObject *bytestring_pyrichcompare(PyObject *me,
 111                                           PyObject *you, int op)
 112 {
 113   int b;
 114   void *mystr, *yourstr;
 115   Py_ssize_t mylen, yourlen, minlen;
 116
 117   if (!PyString_Check(me) || !PyString_Check(you)) RETURN_NOTIMPL;
 118   mystr = PyString_AS_STRING(me); mylen = PyString_GET_SIZE(me);
 119   yourstr = PyString_AS_STRING(you); yourlen = PyString_GET_SIZE(you);
 120
 121   switch (op) {
 122     case Py_EQ:
 123       b = mylen == yourlen && ct_memeq(mystr, yourstr, mylen);
 124       break;
 125     case Py_NE:
 126       b = mylen != yourlen || !ct_memeq(mystr, yourstr, mylen);
 127       break;
 128     default:
 129       minlen = mylen < yourlen ? mylen : yourlen;
 130       b = memcmp(mystr, yourstr, minlen);
 131       if (!b) b = mylen < yourlen ? -1 : mylen > yourlen ? +1 : 0;
 132       switch (op) {
 133         case Py_LT: b = b <  0; break;
 134         case Py_LE: b = b <= 0; break;
 135         case Py_GE: b = b >= 0; break;
 136         case Py_GT: b = b >  0; break;
 137         default: abort();
 138       }
 139   }
 140   if (b) RETURN_TRUE;
 141   else RETURN_FALSE;
 142 }
 143
 144 static PyObject *bytestring_pyconcat(PyObject *x, PyObject *y)
 145 {
 146   const void *xv; Py_ssize_t xsz;
 147   const void *yv; Py_ssize_t ysz;
 148   PyObject *z = 0; char *zp; size_t zsz;
 149
 150   if (PyObject_AsReadBuffer(x, &xv, &xsz) ||
 151       PyObject_AsReadBuffer(y, &yv, &ysz))
 152     goto end;
 153   zsz = (size_t)xsz + (size_t)ysz;
 154   if (xsz < 0 || ysz < 0 || zsz < xsz) VALERR("too long");
 155   z = bytestring_pywrap(0, zsz); zp = PyString_AS_STRING(z);
 156   memcpy(zp, xv, xsz); memcpy(zp + xsz, yv, ysz);
 157 end:
 158   return (z);
 159 }
 160
 161 static PyObject *bytestring_pyrepeat(PyObject *me, Py_ssize_t n)
 162 {
 163   const unsigned char *xp; size_t xsz;
 164   PyObject *z = 0; char *zp; size_t zsz;
 165
 166   xp = (const unsigned char *)PyString_AS_STRING(me);
 167   xsz = PyString_GET_SIZE(me);
 168   if (n < 0 || (n && xsz >= (size_t)-1/n)) VALERR("too long");
 169   zsz = n*xsz; z = bytestring_pywrap(0, zsz); zp = PyString_AS_STRING(z);
 170   if (xsz == 1) memset(zp, *xp, zsz);
 171   else while (zsz) { memcpy(zp, xp, xsz); zp += xsz; zsz -= xsz; }
 172 end:
 173   return (z);
 174 }
 175
 176 static PyObject *bytestring_pyitem(PyObject *me, Py_ssize_t i)
 177 {
 178   PyObject *rc = 0;
 179
 180   if (i < 0 || i >= PyString_GET_SIZE(me)) IXERR("out of range");
 181   rc = bytestring_pywrap(PyString_AS_STRING(me) + i, 1);
 182 end:
 183   return (rc);
 184 }
 185
 186 static PyObject *bytestring_pyslice(PyObject *me, Py_ssize_t i, Py_ssize_t j)
 187 {
 188   PyObject *rc = 0;
 189   size_t n = PyString_GET_SIZE(me);
 190
 191   if (i < 0) i = 0;
 192   if (j < 0) j = 0;
 193   else if (j > n) j = n;
 194   if (j < i) i = j = 0;
 195   if (i == 0 && j == n && me->ob_type == bytestring_pytype)
 196     { Py_INCREF(me); rc = me; goto end; }
 197   rc = bytestring_pywrap(PyString_AS_STRING(me) + i, j - i);
 198 end:
 199   return (rc);
 200 }
 201
 202 static PyObject *bytestring_pysubscript(PyObject *me, PyObject *ix)
 203 {
 204   Py_ssize_t i, j, k, n;
 205   const unsigned char *p;
 206   unsigned char *q;
 207   PyObject *rc = 0;
 208
 209   if (PyIndex_Check(ix)) {
 210     i = PyNumber_AsSsize_t(ix, PyExc_IndexError);
 211     if (i == -1 && PyErr_Occurred()) return (0);
 212     if (i < 0) i += PyString_GET_SIZE(me);
 213     rc = bytestring_pyitem(me, i);
 214   } else if (PySlice_Check(ix)) {
 215     if (PySlice_GetIndicesEx((PySliceObject *)ix, PyString_GET_SIZE(me),
 216                              &i, &j, &k, &n))
 217       return (0);
 218     if (k == 1) return bytestring_pyslice(me, i, j);
 219     rc = bytestring_pywrap(0, n);
 220     p = (unsigned char *)PyString_AS_STRING(me) + i;
 221     q = (unsigned char *)PyString_AS_STRING(rc);
 222     while (n--) { *q++ = *p; p += k; }
 223   } else
 224     TYERR("wanted integer or slice");
 225 end:
 226   return (rc);
 227 }
 228
 229 #define BINOP(name, op)                                                 \
 230   static PyObject *bytestring_py##name(PyObject *x, PyObject *y) {      \
 231     const void *xv, *yv;                                                \
 232     const unsigned char *xp, *yp;                                       \
 233     unsigned char *zp;                                                  \
 234     Py_ssize_t xsz, ysz;                                                \
 235     int i;                                                              \
 236     PyObject *rc = 0;                                                   \
 237     if (PyObject_AsReadBuffer(x, &xv, &xsz) ||                          \
 238         PyObject_AsReadBuffer(y, &yv, &ysz))                            \
 239       goto end;                                                         \
 240     if (xsz != ysz) VALERR("length mismatch");                          \
 241     rc = bytestring_pywrap(0, xsz);                                     \
 242     xp = xv; yp = yv; zp = (unsigned char *)PyString_AS_STRING(rc);     \
 243     for (i = xsz; i > 0; i--) *zp++ = *xp++ op *yp++;                   \
 244   end:                                                                  \
 245     return (rc);                                                        \
 246   }
 247 BINOP(and, &)
 248 BINOP(or, |)
 249 BINOP(xor, ^)
 250
 251 #define UNOP(name, op)                                                  \
 252   static PyObject *bytestring_py##name(PyObject *x) {                   \
 253     const void *xv;                                                     \
 254     const unsigned char *xp;                                            \
 255     unsigned char *zp;                                                  \
 256     Py_ssize_t xsz;                                                     \
 257     int i;                                                              \
 258     PyObject *rc = 0;                                                   \
 259     if (PyObject_AsReadBuffer(x, &xv, &xsz)) goto end;                  \
 260     rc = bytestring_pywrap(0, xsz);                                     \
 261     xp = xv; zp = (unsigned char *)PyString_AS_STRING(rc);              \
 262     for (i = xsz; i > 0; i--) *zp++ = op *xp++;                         \
 263   end:                                                                  \
 264     return (rc);                                                        \
 265   }
 266 UNOP(not, ~)
 267
 268 static PyNumberMethods bytestring_pynumber = {
 269   0,                                    /* @nb_add@ */
 270   0,                                    /* @nb_subtract@ */
 271   0,                                    /* @nb_multiply@ */
 272   0,                                    /* @nb_divide@ */
 273   0,                                    /* @nb_remainder@ */
 274   0,                                    /* @nb_divmod@ */
 275   0,                                    /* @nb_power@ */
 276   0,                                    /* @nb_negative@ */
 277   0,                                    /* @nb_positive@ */
 278   0,                                    /* @nb_absolute@ */
 279   0,                                    /* @nb_nonzero@ */
 280   bytestring_pynot,                     /* @nb_invert@ */
 281   0,                                    /* @nb_lshift@ */
 282   0,                                    /* @nb_rshift@ */
 283   bytestring_pyand,                     /* @nb_and@ */
 284   bytestring_pyxor,                     /* @nb_xor@ */
 285   bytestring_pyor,                      /* @nb_or@ */
 286   0,                                    /* @nb_coerce@ */
 287   0,                                    /* @nb_int@ */
 288   0,                                    /* @nb_long@ */
 289   0,                                    /* @nb_float@ */
 290   0,                                    /* @nb_oct@ */
 291   0,                                    /* @nb_hex@ */
 292 };
 293
 294 static PySequenceMethods bytestring_pysequence = {
 295   0,                                    /* @sq_length@ */
 296   bytestring_pyconcat,                  /* @sq_concat@ */
 297   bytestring_pyrepeat,                  /* @sq_repeat@ */
 298   bytestring_pyitem,                    /* @sq_item@ */
 299   bytestring_pyslice,                   /* @sq_slice@ */
 300   0,                                    /* @sq_ass_item@ */
 301   0,                                    /* @sq_ass_slice@ */
 302   0,                                    /* @sq_contains@ */
 303   0,                                    /* @sq_inplace_concat@ */
 304   0,                                    /* @sq_inplace_repeat@ */
 305 };
 306
 307 static PyMappingMethods bytestring_pymapping = {
 308   0,                                    /* @mp_length@ */
 309   bytestring_pysubscript,               /* @mp_subscript@ */
 310   0,                                    /* @mp_ass_subscript@ */
 311 };
 312
 313 static PyBufferProcs bytestring_pybuffer;
 314
 315 static PyTypeObject bytestring_pytype_skel = {
 316   PyObject_HEAD_INIT(0) 0,              /* Header */
 317   "ByteString",                         /* @tp_name@ */
 318   0,                                    /* @tp_basicsize@ */
 319   0,                                    /* @tp_itemsize@ */
 320
 321   0,                                    /* @tp_dealloc@ */
 322   0,                                    /* @tp_print@ */
 323   0,                                    /* @tp_getattr@ */
 324   0,                                    /* @tp_setattr@ */
 325   0,                                    /* @tp_compare@ */
 326   0,                                    /* @tp_repr@ */
 327   &bytestring_pynumber,                 /* @tp_as_number@ */
 328   &bytestring_pysequence,               /* @tp_as_sequence@ */
 329   &bytestring_pymapping,                /* @tp_as_mapping@ */
 330   0,                                    /* @tp_hash@ */
 331   0,                                    /* @tp_call@ */
 332   0,                                    /* @tp_str@ */
 333   0,                                    /* @tp_getattro@ */
 334   0,                                    /* @tp_setattro@ */
 335   &bytestring_pybuffer,                 /* @tp_as_buffer@ */
 336   Py_TPFLAGS_DEFAULT |                  /* @tp_flags@ */
 337     Py_TPFLAGS_CHECKTYPES |
 338     Py_TPFLAGS_BASETYPE,
 339
 340   /* @tp_doc@ */
 341 "ByteString(STR): byte string class.",
 342
 343   0,                                    /* @tp_traverse@ */
 344   0,                                    /* @tp_clear@ */
 345   bytestring_pyrichcompare,             /* @tp_richcompare@ */
 346   0,                                    /* @tp_weaklistoffset@ */
 347   0,                                    /* @tp_iter@ */
 348   0,                                    /* @tp_iternext@ */
 349   0,                                    /* @tp_methods@ */
 350   0,                                    /* @tp_members@ */
 351   0,                                    /* @tp_getset@ */
 352   0,                                    /* @tp_base@ */
 353   0,                                    /* @tp_dict@ */
 354   0,                                    /* @tp_descr_get@ */
 355   0,                                    /* @tp_descr_set@ */
 356   0,                                    /* @tp_dictoffset@ */
 357   0,                                    /* @tp_init@ */
 358   PyType_GenericAlloc,                  /* @tp_alloc@ */
 359   bytestring_pynew,                     /* @tp_new@ */
 360   0,                                    /* @tp_free@ */
 361   0                                     /* @tp_is_gc@ */
 362 };
 363
 364 /*----- Initialization ----------------------------------------------------*/
 365
 366 static PyMethodDef methods[] = {
 367 #define METHNAME(func) meth_##func
 368   METH  (ctstreq,               "ctstreq(S, T) -> BOOL")
 369   METH  (_ByteString_zero,      "zero(N) -> 0000...00")
 370 #undef METHNAME
 371   { 0 }
 372 };
 373
 374 #define string_pytype &PyString_Type
 375 void bytestring_pyinit(void)
 376 {
 377   INITTYPE(bytestring, string);
 378   addmethods(methods);
 379 }
 380
 381 void bytestring_pyinsert(PyObject *mod)
 382 {
 383   INSERT("ByteString", bytestring_pytype);
 384 }
 385
 386 /*----- That's all, folks -------------------------------------------------*/