diff options
Diffstat (limited to 'Objects')
| -rw-r--r-- | Objects/bytesobject.c | 373 | ||||
| -rw-r--r-- | Objects/object.c | 3 |
2 files changed, 376 insertions, 0 deletions
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c new file mode 100644 index 0000000..8fc089b --- /dev/null +++ b/Objects/bytesobject.c @@ -0,0 +1,373 @@ +/* Bytes object implementation */ + +/* XXX TO DO: optimizations */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" + +/* Direct API functions */ + +PyObject * +PyBytes_FromStringAndSize(const char *sval, Py_ssize_t size) +{ + PyBytesObject *new; + + if (size != 0) { + assert(sval != NULL); + assert(size > 0); + } + + new = PyObject_New(PyBytesObject, &PyBytes_Type); + if (new == NULL) + return NULL; + + if (size > 0) { + new->ob_sval = PyMem_Malloc(size); + if (new->ob_sval == NULL) { + Py_DECREF(new); + return NULL; + } + memcpy(new->ob_sval, sval, size); + new->ob_size = size; + } + + return (PyObject *)new; +} + +Py_ssize_t +PyBytes_Size(PyObject *self) +{ + assert(self != NULL); + assert(PyBytes_Check(self)); + + return ((PyBytesObject *)self)->ob_size; +} + +char * +PyBytes_AsString(PyObject *self) +{ + assert(self != NULL); + assert(PyBytes_Check(self)); + + return ((PyBytesObject *)self)->ob_sval; +} + +int +PyBytes_Resize(PyObject *self, Py_ssize_t size) +{ + void *sval; + + assert(self != NULL); + assert(PyBytes_Check(self)); + assert(size >= 0); + + sval = PyMem_Realloc(((PyBytesObject *)self)->ob_sval, size); + if (sval == NULL) { + PyErr_NoMemory(); + return -1; + } + + ((PyBytesObject *)self)->ob_sval = sval; + ((PyBytesObject *)self)->ob_size = size; + + return 0; +} + +/* Functions stuffed into the type object */ + +static Py_ssize_t +bytes_length(PyBytesObject *self) +{ + return self->ob_size; +} + +static PyObject * +bytes_getitem(PyBytesObject *self, Py_ssize_t i) +{ + if (i < 0) + i += self->ob_size; + if (i < 0 || i >= self->ob_size) { + PyErr_SetString(PyExc_IndexError, "bytes index out of range"); + return NULL; + } + return PyInt_FromLong((unsigned char)(self->ob_sval[i])); +} + +static long +bytes_nohash(PyObject *self) +{ + PyErr_SetString(PyExc_TypeError, "bytes objects are unhashable"); + return -1; +} + +static int +bytes_init(PyBytesObject *self, PyObject *args, PyObject *kwds) +{ + static char *kwlist[] = {"sequence", 0}; + PyObject *arg = NULL; + PyObject *it; /* iter(arg) */ + PyObject *(*iternext)(PyObject *); + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:bytes", kwlist, &arg)) + return -1; + + /* Verify list invariants established by PyType_GenericAlloc() */ + if (self->ob_size != 0) { + assert(self->ob_sval != NULL); + assert(self->ob_size > 0); + } + + /* Empty previous contents */ + if (PyBytes_Resize((PyObject *)self, 0) < 0) + return -1; + + /* Quick check if we're done */ + if (arg == 0) + return 0; + + /* XXX Optimize this if the arguments is a list, tuple, or bytes */ + + /* Get the iterator */ + it = PyObject_GetIter(arg); + if (it == NULL) + return 0; + iternext = *it->ob_type->tp_iternext; + + /* Run the iterator to exhaustion */ + for (;;) { + PyObject *item; + Py_ssize_t value; + + /* Get the next item */ + item = iternext(it); + if (item == NULL) { + if (PyErr_Occurred()) { + if (!PyErr_ExceptionMatches(PyExc_StopIteration)) + goto error; + PyErr_Clear(); + } + break; + } + + /* Interpret it as an int (__index__) */ + value = PyNumber_Index(item); + if (value == -1 && PyErr_Occurred()) + goto error; + + /* Range check */ + if (value < 0 || value >= 256) { + PyErr_SetString(PyExc_ValueError, "bytes must be in range(0, 256)"); + goto error; + } + + /* Append the byte */ + /* XXX Speed this up */ + if (PyBytes_Resize((PyObject *)self, self->ob_size+1) < 0) + goto error; + self->ob_sval[self->ob_size-1] = value; + } + + /* Clean up and return success */ + Py_DECREF(it); + return 0; + + error: + /* Error handling when it != NULL */ + Py_DECREF(it); + return -1; +} + +static PyObject * +bytes_repr(PyBytesObject *self) +{ + PyObject *list; + PyObject *str; + PyObject *result; + int err; + int i; + + if (self->ob_size == 0) + return PyString_FromString("bytes()"); + + list = PyList_New(0); + if (list == NULL) + return NULL; + + str = PyString_FromString("bytes(["); + if (str == NULL) + goto error; + + err = PyList_Append(list, str); + Py_DECREF(str); + if (err < 0) + goto error; + + for (i = 0; i < self->ob_size; i++) { + char buffer[20]; + sprintf(buffer, ", 0x%02x", (unsigned char) (self->ob_sval[i])); + str = PyString_FromString((i == 0) ? buffer+2 : buffer); + if (str == NULL) + goto error; + err = PyList_Append(list, str); + Py_DECREF(str); + if (err < 0) + goto error; + } + + str = PyString_FromString("])"); + if (str == NULL) + goto error; + + err = PyList_Append(list, str); + Py_DECREF(str); + if (err < 0) + goto error; + + str = PyString_FromString(""); + if (str == NULL) + goto error; + + result = _PyString_Join(str, list); + Py_DECREF(str); + Py_DECREF(list); + return result; + + error: + /* Error handling when list != NULL */ + Py_DECREF(list); + return NULL; +} + +static PyObject * +bytes_richcompare(PyBytesObject *self, PyBytesObject *other, int op) +{ + PyObject *res; + int minsize; + int cmp; + + if (!PyBytes_Check(self) || !PyBytes_Check(other)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + + if (self->ob_size != other->ob_size && (op == Py_EQ || op == Py_NE)) { + /* Shortcut: if the lengths differ, the objects differ */ + cmp = (op == Py_NE); + } + else { + minsize = self->ob_size; + if (other->ob_size < minsize) + minsize = other->ob_size; + + cmp = memcmp(self->ob_sval, other->ob_sval, minsize); + /* In ISO C, memcmp() guarantees to use unsigned bytes! */ + + if (cmp == 0) { + if (self->ob_size < other->ob_size) + cmp = -1; + else if (self->ob_size > other->ob_size) + cmp = 1; + } + + switch (op) { + case Py_LT: cmp = cmp < 0; break; + case Py_LE: cmp = cmp <= 0; break; + case Py_EQ: cmp = cmp == 0; break; + case Py_NE: cmp = cmp != 0; break; + case Py_GT: cmp = cmp > 0; break; + case Py_GE: cmp = cmp >= 0; break; + } + } + + res = cmp ? Py_True : Py_False; + Py_INCREF(res); + return res; +} + +static void +bytes_dealloc(PyBytesObject *self) +{ + if (self->ob_sval != 0) { + PyMem_Free(self->ob_sval); + } + self->ob_type->tp_free((PyObject *)self); +} + +static PySequenceMethods bytes_as_sequence = { + (lenfunc)bytes_length, /*sq_length*/ + (binaryfunc)0, /*sq_concat*/ + (ssizeargfunc)0, /*sq_repeat*/ + (ssizeargfunc)bytes_getitem, /*sq_item*/ + (ssizessizeargfunc)0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + (objobjproc)0, /*sq_contains*/ +}; + +static PyMappingMethods bytes_as_mapping = { + (lenfunc)bytes_length, + (binaryfunc)0, + 0, +}; + +static PyBufferProcs bytes_as_buffer = { +/* + (readbufferproc)bytes_buffer_getreadbuf, + (writebufferproc)bytes_buffer_getwritebuf, + (segcountproc)bytes_buffer_getsegcount, + (charbufferproc)bytes_buffer_getcharbuf, +*/ +}; + +static PyMethodDef +bytes_methods[] = { + {NULL, NULL} +}; + +PyDoc_STRVAR(bytes_doc, +"bytes([iterable]) -> new array of bytes.\n\ +\n\ +If an argument is given it must be an iterable yielding ints in range(256)."); + +PyTypeObject PyBytes_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, + "bytes", + sizeof(PyBytesObject), + 0, + (destructor)bytes_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)bytes_repr, /* tp_repr */ + 0, /* tp_as_number */ + &bytes_as_sequence, /* tp_as_sequence */ + &bytes_as_mapping, /* tp_as_mapping */ + bytes_nohash, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + &bytes_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES, /* tp_flags */ /* bytes is 'final' or 'sealed' */ + bytes_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)bytes_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + bytes_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)bytes_init, /* tp_init */ + PyType_GenericAlloc, /* tp_alloc */ + PyType_GenericNew, /* tp_new */ + PyObject_Del, /* tp_free */ +}; diff --git a/Objects/object.c b/Objects/object.c index a75c14e..9a451d2 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -1881,6 +1881,9 @@ _Py_ReadyTypes(void) if (PyType_Ready(&PyBool_Type) < 0) Py_FatalError("Can't initialize 'bool'"); + if (PyType_Ready(&PyBytes_Type) < 0) + Py_FatalError("Can't initialize 'bytes'"); + if (PyType_Ready(&PyString_Type) < 0) Py_FatalError("Can't initialize 'str'"); |