X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/c461c9b380b56a41399e5f540e4bb97cfd9ceffe..2a3c9d9a943cda6de14e9dd1f98d37eea2103ffa:/bytestring.c

diff --git a/bytestring.c b/bytestring.c
index 99c114c..ced62b4 100644
--- a/bytestring.c
+++ b/bytestring.c
@@ -30,20 +30,43 @@
 
 /*----- Main code ---------------------------------------------------------*/
 
-PyTypeObject *bytestring_pytype;
+static PyTypeObject *bytestring_pytype;
 
-static PyObject *dowrap(PyTypeObject *ty, const void *p, size_t n)
+static PyObject *empty, *bytev[256];
+
+static PyObject *allocate(PyTypeObject *ty, size_t n)
 {
-  PyStringObject *x = (PyStringObject *)ty->tp_alloc(ty, n);
-  if (p) memcpy(x->ob_sval, p, n);
+  BINOBJ *x;
+  x = (BINOBJ *)ty->tp_alloc(ty, n);
   x->ob_sval[n] = 0;
-#ifdef CACHE_HASH
+#if defined(CACHE_HASH) || PY_VERSION_HEX >= 0x02030000
   x->ob_shash = -1;
 #endif
   x->ob_sstate = SSTATE_NOT_INTERNED;
   return ((PyObject *)x);
 }
 
+static PyObject *dowrap(PyTypeObject *ty, const void *p, size_t n)
+{
+  PyObject *x;
+  int ch;
+
+  if (p && ty == bytestring_pytype) {
+    if (!n) {
+      if (!empty) empty = allocate(ty, 0);
+      Py_INCREF(empty); return (empty);
+    } else if (n == 1 && (ch = *(unsigned char *)p) < sizeof(bytev)) {
+      if (!bytev[ch])
+	{ bytev[ch] = allocate(ty, 1); *BIN_PTR(bytev[ch]) = ch; }
+      Py_INCREF(bytev[ch]); return (bytev[ch]);
+    }
+  }
+
+  x = allocate(ty, n);
+  if (p) memcpy(BIN_PTR(x), p, n);
+  return (x);
+}
+
 PyObject *bytestring_pywrap(const void *p, size_t n)
   { return (dowrap(bytestring_pytype, p, n)); }
 
@@ -53,29 +76,162 @@ PyObject *bytestring_pywrapbuf(buf *b)
 static PyObject *bytestring_pynew(PyTypeObject *ty,
 				  PyObject *arg, PyObject *kw)
 {
-  const char *p;
-  int n;
-  static char *kwlist[] = { "data", 0 };
-  if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#:new", kwlist, &p, &n))
+  struct bin in;
+  static const char *const kwlist[] = { "data", 0 };
+  if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&:new", KWLIST, convbin, &in))
     return (0);
-  return (dowrap(ty, p, n));
+  return (dowrap(ty, in.p, in.sz));
+}
+
+static PyObject *meth_ctstreq(PyObject *me, PyObject *arg)
+{
+  struct bin s0, s1;
+  if (!PyArg_ParseTuple(arg, "O&O&:ctstreq", convbin, &s0 , convbin, &s1))
+    goto end;
+  if (s0.sz == s1.sz && ct_memeq(s0.p, s1.p, s0.sz)) RETURN_TRUE;
+  else RETURN_FALSE;
+end:
+  return (0);
+}
+
+static PyObject *bymeth_zero(PyObject *me, PyObject *arg)
+{
+  size_t sz;
+  PyObject *rc = 0;
+  if (!PyArg_ParseTuple(arg, "O&:zero", convszt, &sz)) goto end;
+  rc = bytestring_pywrap(0, sz);
+  memset(BIN_PTR(rc), 0, sz);
+end:
+  return (rc);
+}
+
+static PyObject *bytestring_pyrichcompare(PyObject *me,
+					  PyObject *you, int op)
+{
+  struct bin s0, s1;
+  int b;
+  Py_ssize_t minlen;
+
+  s0.p = BIN_PTR(me); s0.sz = BIN_LEN(me);
+  if (!convbin(you, &s1)) { PyErr_Clear(); RETURN_NOTIMPL; }
+
+  switch (op) {
+    case Py_EQ:
+      b = s0.sz == s1.sz && ct_memeq(s0.p, s1.p, s1.sz);
+      break;
+    case Py_NE:
+      b = s0.sz != s1.sz || !ct_memeq(s0.p, s1.p, s1.sz);
+      break;
+    default:
+      minlen = s0.sz < s1.sz ? s0.sz : s1.sz;
+      b = memcmp(s0.p, s1.p, minlen);
+      if (!b) b = s0.sz < s1.sz ? -1 : s0.sz > s1.sz ? +1 : 0;
+      switch (op) {
+	case Py_LT: b = b <  0; break;
+	case Py_LE: b = b <= 0; break;
+	case Py_GE: b = b >= 0; break;
+	case Py_GT: b = b >  0; break;
+	default: abort();
+      }
+  }
+  if (b) RETURN_TRUE;
+  else RETURN_FALSE;
+}
+
+static PyObject *bytestring_pyconcat(PyObject *x, PyObject *y)
+{
+  struct bin xx, yy;
+  PyObject *z = 0; char *zp; size_t zsz;
+
+  if (!convbin(x, &xx) || !convbin(y, &yy)) goto end;
+  zsz = (size_t)xx.sz + (size_t)yy.sz;
+  if (xx.sz < 0 || yy.sz < 0 || zsz < xx.sz) VALERR("too long");
+  z = bytestring_pywrap(0, zsz); zp = BIN_PTR(z);
+  memcpy(zp, xx.p, xx.sz); memcpy(zp + xx.sz, yy.p, yy.sz);
+end:
+  return (z);
+}
+
+static PyObject *bytestring_pyrepeat(PyObject *me, Py_ssize_t n)
+{
+  const unsigned char *xp; size_t xsz;
+  PyObject *z = 0; char *zp; size_t zsz;
+
+  xp = (const unsigned char *)BIN_PTR(me);
+  xsz = BIN_LEN(me);
+  if (n < 0 || (n && xsz >= (size_t)-1/n)) VALERR("too long");
+  zsz = n*xsz; z = bytestring_pywrap(0, zsz); zp = BIN_PTR(z);
+  if (xsz == 1) memset(zp, *xp, zsz);
+  else while (zsz) { memcpy(zp, xp, xsz); zp += xsz; zsz -= xsz; }
+end:
+  return (z);
+}
+
+static PyObject *bytestring_pyitem(PyObject *me, Py_ssize_t i)
+{
+  PyObject *rc = 0;
+
+  if (i < 0 || i >= BIN_LEN(me)) IXERR("out of range");
+  rc = bytestring_pywrap(BIN_PTR(me) + i, 1);
+end:
+  return (rc);
+}
+
+static PyObject *bytestring_pyslice(PyObject *me, Py_ssize_t i, Py_ssize_t j)
+{
+  PyObject *rc = 0;
+  size_t n = BIN_LEN(me);
+
+  if (i < 0) i = 0;
+  if (j < 0) j = 0;
+  else if (j > n) j = n;
+  if (j < i) i = j = 0;
+  if (i == 0 && j == n && Py_TYPE(me) == bytestring_pytype)
+    { Py_INCREF(me); rc = me; goto end; }
+  rc = bytestring_pywrap(BIN_PTR(me) + i, j - i);
+end:
+  return (rc);
+}
+
+static PyObject *bytestring_pysubscript(PyObject *me, PyObject *ix)
+{
+  Py_ssize_t i, j, k, n;
+  const unsigned char *p;
+  unsigned char *q;
+  PyObject *rc = 0;
+
+  if (PyIndex_Check(ix)) {
+    i = PyNumber_AsSsize_t(ix, PyExc_IndexError);
+    if (i == -1 && PyErr_Occurred()) return (0);
+    if (i < 0) i += BIN_LEN(me);
+    rc = bytestring_pyitem(me, i);
+  } else if (PySlice_Check(ix)) {
+    if (PySlice_GetIndicesEx((PySliceObject *)ix, BIN_LEN(me),
+			     &i, &j, &k, &n))
+      return (0);
+    if (k == 1) return bytestring_pyslice(me, i, j);
+    rc = bytestring_pywrap(0, n);
+    p = (unsigned char *)BIN_PTR(me) + i;
+    q = (unsigned char *)BIN_PTR(rc);
+    while (n--) { *q++ = *p; p += k; }
+  } else
+    TYERR("wanted integer or slice");
+end:
+  return (rc);
 }
 
 #define BINOP(name, op)							\
   static PyObject *bytestring_py##name(PyObject *x, PyObject *y) {	\
-    const void *xv, *yv;						\
+    struct bin xx, yy;							\
     const unsigned char *xp, *yp;					\
     unsigned char *zp;							\
-    int xsz, ysz;							\
     int i;								\
     PyObject *rc = 0;							\
-    if (PyObject_AsReadBuffer(x, &xv, &xsz) ||				\
-	PyObject_AsReadBuffer(y, &yv, &ysz))				\
-      goto end;								\
-    if (xsz != ysz) VALERR("length mismatch");				\
-    rc = bytestring_pywrap(0, xsz);					\
-    xp = xv; yp = yv; zp = (unsigned char *)PyString_AS_STRING(rc);	\
-    for (i = xsz; i > 0; i--) *zp++ = *xp++ op *yp++;			\
+    if (!convbin(x, &xx) || !convbin(y, &yy)) goto end;			\
+    if (xx.sz != yy.sz) VALERR("length mismatch");			\
+    rc = bytestring_pywrap(0, xx.sz);					\
+    xp = xx.p; yp = yy.p; zp = (unsigned char *)BIN_PTR(rc);		\
+    for (i = xx.sz; i > 0; i--) *zp++ = *xp++ op *yp++;			\
   end:									\
     return (rc);							\
   }
@@ -85,22 +241,28 @@ BINOP(xor, ^)
 
 #define UNOP(name, op)							\
   static PyObject *bytestring_py##name(PyObject *x) {			\
-    const void *xv;							\
+    struct bin xx;							\
     const unsigned char *xp;						\
     unsigned char *zp;							\
-    int xsz;								\
     int i;								\
     PyObject *rc = 0;							\
-    if (PyObject_AsReadBuffer(x, &xv, &xsz)) goto end;			\
-    rc = bytestring_pywrap(0, xsz);					\
-    xp = xv; zp = (unsigned char *)PyString_AS_STRING(rc);		\
-    for (i = xsz; i > 0; i--) *zp++ = op *xp++;				\
+    if (!convbin(x, &xx)) goto end;					\
+    rc = bytestring_pywrap(0, xx.sz);					\
+    xp = xx.p; zp = (unsigned char *)BIN_PTR(rc);			\
+    for (i = xx.sz; i > 0; i--) *zp++ = op *xp++;			\
   end:									\
     return (rc);							\
   }
 UNOP(not, ~)
 
-static PyNumberMethods bytestring_pynumber = {
+static const PyMethodDef bytestring_pymethods[] = {
+#define METHNAME(name) bymeth_##name
+  SMTH	(zero,		"zero(N) -> 0000...00")
+#undef METHNAME
+  { 0 }
+};
+
+static const PyNumberMethods bytestring_pynumber = {
   0,					/* @nb_add@ */
   0,					/* @nb_subtract@ */
   0,					/* @nb_multiply@ */
@@ -126,10 +288,27 @@ static PyNumberMethods bytestring_pynumber = {
   0,					/* @nb_hex@ */
 };
 
-static PyBufferProcs bytestring_pybuffer;
+static const PySequenceMethods bytestring_pysequence = {
+  0,					/* @sq_length@ */
+  bytestring_pyconcat,			/* @sq_concat@ */
+  bytestring_pyrepeat,			/* @sq_repeat@ */
+  bytestring_pyitem,			/* @sq_item@ */
+  bytestring_pyslice,			/* @sq_slice@ */
+  0,					/* @sq_ass_item@ */
+  0,					/* @sq_ass_slice@ */
+  0,					/* @sq_contains@ */
+  0,					/* @sq_inplace_concat@ */
+  0,					/* @sq_inplace_repeat@ */
+};
+
+static const PyMappingMethods bytestring_pymapping = {
+  0,					/* @mp_length@ */
+  bytestring_pysubscript,		/* @mp_subscript@ */
+  0,					/* @mp_ass_subscript@ */
+};
 
-static PyTypeObject bytestring_pytype_skel = {
-  PyObject_HEAD_INIT(0) 0,		/* Header */
+static const PyTypeObject bytestring_pytype_skel = {
+  PyVarObject_HEAD_INIT(0, 0)		/* Header */
   "ByteString",				/* @tp_name@ */
   0,					/* @tp_basicsize@ */
   0,					/* @tp_itemsize@ */
@@ -140,29 +319,29 @@ static PyTypeObject bytestring_pytype_skel = {
   0,					/* @tp_setattr@ */
   0,					/* @tp_compare@ */
   0,					/* @tp_repr@ */
-  &bytestring_pynumber,			/* @tp_as_number@ */
-  0,					/* @tp_as_sequence@ */
-  0,					/* @tp_as_mapping@ */
+  PYNUMBER(bytestring),			/* @tp_as_number@ */
+  PYSEQUENCE(bytestring),		/* @tp_as_sequence@ */
+  PYMAPPING(bytestring),		/* @tp_as_mapping@ */
   0,					/* @tp_hash@ */
   0,					/* @tp_call@ */
   0,					/* @tp_str@ */
   0,					/* @tp_getattro@ */
   0,					/* @tp_setattro@ */
-  &bytestring_pybuffer,			/* @tp_as_buffer@ */
+  0,					/* @tp_as_buffer@ */
   Py_TPFLAGS_DEFAULT |			/* @tp_flags@ */
     Py_TPFLAGS_CHECKTYPES |
     Py_TPFLAGS_BASETYPE,
 
   /* @tp_doc@ */
-"Byte string class.",
+  "ByteString(STR): byte string class.",
 
   0,					/* @tp_traverse@ */
   0,					/* @tp_clear@ */
-  0,					/* @tp_richcompare@ */
+  bytestring_pyrichcompare,		/* @tp_richcompare@ */
   0,					/* @tp_weaklistoffset@ */
   0,					/* @tp_iter@ */
   0,					/* @tp_iternext@ */
-  0,					/* @tp_methods@ */
+  PYMETHODS(bytestring),		/* @tp_methods@ */
   0,					/* @tp_members@ */
   0,					/* @tp_getset@ */
   0,					/* @tp_base@ */
@@ -179,10 +358,18 @@ static PyTypeObject bytestring_pytype_skel = {
 
 /*----- Initialization ----------------------------------------------------*/
 
-#define string_pytype &PyString_Type
+static const PyMethodDef methods[] = {
+#define METHNAME(func) meth_##func
+  METH	(ctstreq,	"ctstreq(S, T) -> BOOL")
+#undef METHNAME
+  { 0 }
+};
+
+#define string_pytype &BIN_TYPE
 void bytestring_pyinit(void)
 {
   INITTYPE(bytestring, string);
+  addmethods(methods);
 }
 
 void bytestring_pyinsert(PyObject *mod)