Ticket #225: cpyamf.diff

cpyamf/util.h

@@ +1 @@
+#ifndef CPYAMF_UTIL_H
+#define CPYAMF_UTIL_H
+
+#ifdef __cpluscplus
+extern "C" {
+#endif
+/**
+ *
+ * util.h
+ *
+ * Defines the BufferedByteStream.
+ *
+ **/
+#include <Python.h>
+
+#define CPYAMF_UTIL_IMPORT                                                   \
+        cPyAmf_BufferedByteStream = (struct cPyAmf_BufferedByteStream_CAPI*)     \
+                                PyCObject_Import("cpyamf.util",              \
+                                                 "BufferedByteStream_CAPI");
+
+typedef struct {
+    PyObject_HEAD
+    PyObject* buffer; /* cStringIO buffer */
+    char endian;
+} BufferedByteStream;
+
+static struct cPyAmf_BufferedByteStream_CAPI {
+        // TODO: Add more methods here as deemed necessary.
+        int (*init)(PyObject*, PyObject*, int); /* (self, buf_obj, rewind) */
+        PyTypeObject* Type;
+} *cPyAmf_BufferedByteStream;
+
+
+#define ENDIAN_NETWORK '!'
+#define ENDIAN_NATIVE '@'
+#define ENDIAN_LITTLE '<'
+#define ENDIAN_BIG '>'
+
+
+
+#define BufferedByteStream_Check(O) ((O)->ob_type==cPyAmf_BufferedByteStream->Type)
+#ifdef __cpluscplus
+}
+#endif
+#endif /* !CPYAMF_UTIL_H */

cpyamf/util.c

@@ +1 @@
+#include <Python.h>
+
+#include "util.h"
+
+#include <cStringIO.h>
+#include <stdio.h>
+#include <structmember.h>
+
+/* Useful Forward Declarations */
+static PyObject * BufferedByteStream_tell(BufferedByteStream *);
+static PyObject * BufferedByteStream_at_eof(BufferedByteStream *);
+static PyObject * BufferedByteStream_remaining(BufferedByteStream *);
+static PyObject * BufferedByteStream_seek(BufferedByteStream *, PyObject *, PyObject *);
+static PyObject * BufferedByteStream_peek(BufferedByteStream *, PyObject *, PyObject *);
+static PyObject * BufferedByteStream_read(BufferedByteStream *, PyObject *, PyObject *);
+static PyObject * BufferedByteStream_readline(BufferedByteStream *);
+static PyObject * BufferedByteStream_readlines(BufferedByteStream *, PyObject *, PyObject *);
+static PyObject * BufferedByteStream_write(BufferedByteStream *, PyObject *);
+static PyObject * BufferedByteStream_writelines(BufferedByteStream *, PyObject *);
+static PyObject * BufferedByteStream_getvalue(BufferedByteStream *);
+static PyObject * BufferedByteStream_truncate(BufferedByteStream *, PyObject *, PyObject *);
+static PyObject * BufferedByteStream_flush(BufferedByteStream *);
+static PyObject * BufferedByteStream_close(BufferedByteStream *);
+static int BufferedByteStream_init_(BufferedByteStream *, PyObject *, int);
+
+staticforward PyTypeObject BufferedByteStreamType;
+#undef BufferedByteStream_Check
+#define BufferedByteStream_Check(O) ((O)->ob_type==&BufferedByteStreamType)
+
+/**
+ * Utility Functions
+ **/
+
+static int
+get_long(PyObject *v, long *p)
+{
+    long x;
+
+    x = PyLong_AsLong(v);
+    if (x == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *p = x;
+    return 0;
+}
+
+static int
+get_ulong(PyObject *v, unsigned long *p)
+{
+    unsigned long x;
+    
+    x = PyLong_AsUnsignedLong(v);
+    if (PyErr_Occurred()) {
+        return -1;
+    }
+    *p = x;
+    return 0;
+}
+
+static PyObject *
+unpack_uint(BufferedByteStream *self, const char *buf, long num_bytes)
+{
+    unsigned long x;
+    const unsigned char *bytes;
+
+    x = 0;
+    bytes = (const unsigned char *) buf;
+    do
+    {
+        if ( (self->endian==ENDIAN_BIG) ||
+             (self->endian==ENDIAN_NETWORK) )
+        {
+            x = (x<<8) | *bytes++;
+        }
+        else
+        {
+            x = (x<<8) | bytes[num_bytes-1];
+        }        
+    } while (--num_bytes > 0);
+    return PyLong_FromUnsignedLong(x);
+}
+
+static PyObject *
+unpack_int(BufferedByteStream *self, const char *buf, long num_bytes)
+{
+    long x;
+    Py_ssize_t bytes_left;
+    const unsigned char *bytes;
+
+    x = 0;
+    bytes_left = num_bytes;
+    bytes = (const unsigned char *) buf;
+    do
+    {
+        if ( (self->endian==ENDIAN_BIG) ||
+             (self->endian==ENDIAN_NETWORK) )
+        {
+            x = (x<<8) | *bytes++;
+        }
+        else
+        {
+            x = (x<<8) | bytes[bytes_left-1];
+        }        
+    } while (--bytes_left > 0);
+    /* Extend the sign bit. */
+    if (SIZEOF_LONG > num_bytes)
+    {
+        x |= -(x & (1L << ((8 *num_bytes) - 1)));
+    }
+    return PyLong_FromLong(x);
+}
+
+static int
+pack_uint(BufferedByteStream *self, unsigned long x, Py_ssize_t num_bytes)
+{
+    char buf[num_bytes];
+
+    if (num_bytes != SIZEOF_LONG) {
+        unsigned long maxint = 1;
+        maxint <<= (unsigned long)(num_bytes * 8);
+        if (x >= maxint)
+        {
+            PyErr_SetString(PyExc_OverflowError, "integer out of range");
+            return -1;
+        }
+    }
+    Py_ssize_t i=num_bytes; 
+    while(i>0)
+    {
+        switch(self->endian)
+        {
+            case ENDIAN_BIG:
+            case ENDIAN_NETWORK:
+                buf[--i] = (char)x;
+                break;
+            case ENDIAN_LITTLE:
+                buf[num_bytes-i] = (char)x;
+                i--;
+                break;
+            case ENDIAN_NATIVE:
+                buf[num_bytes-i] = ((char *)&x)[num_bytes-i];
+                i--;
+        }
+        x >>= 8;
+    }
+    PycStringIO->cwrite(self->buffer, buf, num_bytes);
+    return 0;
+}
+
+static int
+pack_int(BufferedByteStream *self, long x, Py_ssize_t num_bytes)
+{
+    char buf[num_bytes];
+
+    if (num_bytes != SIZEOF_LONG) {
+        long maxint = 1;
+        maxint <<= (unsigned long)(num_bytes * 8);
+        if (x >= maxint)
+        {
+            PyErr_SetString(PyExc_OverflowError, "integer out of range");
+            return -1;
+        }
+    }
+    Py_ssize_t i=num_bytes; 
+    while(i>0)
+    {
+        switch(self->endian)
+        {
+            case ENDIAN_BIG:
+            case ENDIAN_NETWORK:
+                buf[--i] = ((char *)&x)[0];
+                break;
+            case ENDIAN_LITTLE:
+                buf[num_bytes-i] = ((char *)&x)[0];
+                i--;
+                break;
+            case ENDIAN_NATIVE:
+                buf[num_bytes-i] = ((char *)&x)[num_bytes-i];
+                i--;
+        }
+        x >>= 8;
+    }
+    PycStringIO->cwrite(self->buffer, buf, num_bytes);
+    return 0;
+}
+
+/**
+ * BufferedByteStream methods
+ **/
+static void
+BufferedByteStream_dealloc(BufferedByteStream *self)
+{
+    Py_XDECREF(self->buffer);
+    self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *
+BufferedByteStream_tell(BufferedByteStream *self)
+{
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    return PyObject_CallMethod(self->buffer, "tell", NULL);
+}
+
+static PyObject *
+BufferedByteStream_at_eof(BufferedByteStream *self)
+{
+    PyObject *obj_remaining, *result;
+    int remaining;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    /* at_eof <=> remaining==0 */
+
+    obj_remaining = BufferedByteStream_remaining(self);
+    remaining = PyInt_AsLong(obj_remaining);
+    Py_XDECREF(obj_remaining);
+
+    result = PyBool_FromLong(remaining==0);
+    Py_INCREF(result);
+
+    return result;
+}
+
+static PyObject *
+BufferedByteStream_remaining(BufferedByteStream *self)
+{
+    PyObject *cur_pos, *end_pos, *tmp, *result;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    cur_pos = BufferedByteStream_tell(self);
+
+    PyObject_CallMethod(self->buffer, "seek", "ii", 0, 2);
+    end_pos = BufferedByteStream_tell(self);
+
+    tmp = PyObject_CallMethod(self->buffer, "seek", "Oi", cur_pos, 0);
+    Py_XDECREF(tmp);
+
+    result = PyNumber_Subtract(end_pos, cur_pos);
+    Py_XDECREF(end_pos);
+    Py_XDECREF(cur_pos);
+
+    return result;
+}
+
+static PyObject *
+BufferedByteStream_seek(BufferedByteStream *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *obj_pos = NULL;
+    PyObject *obj_mode = NULL;
+    static char *kwlist[] = {"pos", "mode", NULL};
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", kwlist, &obj_pos, &obj_mode))
+        return NULL;
+
+    if (!obj_mode)
+        obj_mode = PyInt_FromLong(0);
+
+    return PyObject_CallMethod(self->buffer, "seek", "OO", obj_pos, obj_mode);
+}
+
+static PyObject *
+BufferedByteStream_peek(BufferedByteStream *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *obj_size = NULL;
+    static char *kwlist[] = {"size", NULL};
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &obj_size))
+        return NULL;
+
+    Py_ssize_t size = 1;
+    if (obj_size)
+        size = PyInt_AsLong(obj_size);
+
+    if (size==-1 && PyErr_Occurred())
+        return NULL;
+
+    PyObject *old_pos = BufferedByteStream_tell(self);
+
+    char *buf = NULL;
+    size = PycStringIO->cread(self->buffer, &buf, size);
+    PyObject *result = PyString_FromStringAndSize(buf, size);
+
+    PyObject_CallMethod(self->buffer, "seek", "Oi", old_pos, 0);
+    Py_XDECREF(old_pos);
+
+    return result;
+}
+
+static PyObject *
+BufferedByteStream_read(BufferedByteStream *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *obj_n = NULL;
+    static char *kwlist[] = {"n", NULL};
+    Py_ssize_t n = -1;
+    char *buf = NULL;
+    int chars_received;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &obj_n))
+        return NULL;
+
+    if (obj_n)
+        n = PyInt_AsLong(obj_n);
+
+    if (n==-1 && PyErr_Occurred())
+        return NULL;
+
+    chars_received = PycStringIO->cread(self->buffer, &buf, n);
+    if (n>chars_received)
+    {
+        if(chars_received>0)
+            PyErr_SetNone(PyExc_IOError);
+        else
+            PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+    return PyString_FromStringAndSize(buf, chars_received);
+}
+
+static PyObject *
+BufferedByteStream_readline(BufferedByteStream *self)
+{
+    char *buf = NULL;
+    int len;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    len = PycStringIO->creadline(self->buffer, &buf);
+    return PyString_FromStringAndSize(buf, len);
+}
+
+static PyObject *
+BufferedByteStream_readlines(BufferedByteStream *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *obj_sizehint = NULL;
+    static char *kwlist[] = {"sizehint", NULL};
+    Py_ssize_t sizehint = 0;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &obj_sizehint))
+        return NULL;
+
+    if (obj_sizehint)
+        sizehint = PyInt_AsLong(obj_sizehint);
+
+    if (sizehint==-1 && PyErr_Occurred())
+        return NULL;
+
+    return PyObject_CallMethod(self->buffer, "readlines", "i", sizehint);
+}
+
+static PyObject *
+BufferedByteStream_write(BufferedByteStream *self, PyObject *obj)
+{
+    char *buffer;
+    Py_ssize_t length;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if(PyString_AsStringAndSize(obj, &buffer, &length))
+        return NULL;
+
+    PycStringIO->cwrite(self->buffer, buffer, length);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_writelines(BufferedByteStream *self, PyObject *iterable)
+{
+    PyObject *tmp;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    tmp = PyObject_CallMethod(self->buffer, "writelines", "O", iterable);
+    Py_XDECREF(tmp);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_getvalue(BufferedByteStream *self)
+{
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    return PyObject_CallMethod(self->buffer, "getvalue", "");
+}
+
+static PyObject *
+BufferedByteStream_truncate(BufferedByteStream *self, PyObject *args, PyObject * kwargs)
+{
+    PyObject *obj_size = NULL, *tmp;
+    static char *kwlist[] = {"size", NULL};
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &obj_size))
+        return NULL;
+
+    if (!obj_size)
+        obj_size = PyInt_FromLong(0);
+    
+    tmp = PyObject_CallMethod(self->buffer, "truncate", "O", obj_size);
+    Py_XDECREF(tmp);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_flush(BufferedByteStream *self)
+{
+    PyObject *tmp;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    tmp = PyObject_CallMethod(self->buffer, "flush", NULL);
+    Py_XDECREF(tmp);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_close(BufferedByteStream *self)
+{
+    if(self->buffer)
+    {
+        PyObject *tmp = PyObject_CallMethod(self->buffer, "close", NULL);
+        Py_XDECREF(tmp);
+
+        tmp = self->buffer;
+        self->buffer = NULL;
+        Py_XDECREF(tmp);
+    }
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+/**
+ * BufferedByteStream Type Read/Write Methods
+ **/
+static PyObject *
+BufferedByteStream_read_uchar(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 1) != 1)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+
+    return PyInt_FromLong((long) *(unsigned char *)buf);
+}
+
+static PyObject *
+BufferedByteStream_write_uchar(BufferedByteStream *self, PyObject *c)
+{
+    unsigned long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_ulong(c, &val))
+        return NULL;
+    if (val < 0 || val > 255)
+    {
+        PyErr_SetString(PyExc_OverflowError, "uchar not in range");
+        return NULL;
+    }
+
+    PycStringIO->cwrite(self->buffer, (char *)&val, 1);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_char(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if(PycStringIO->cread(self->buffer, &buf, 1) != 1)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+    return PyInt_FromLong((long) *(char *)buf);
+}
+
+static PyObject *
+BufferedByteStream_write_char(BufferedByteStream *self, PyObject *c)
+{
+    long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_long(c, &val))
+        return NULL;
+    if (val < -128 || val > 127)
+    {
+        PyErr_SetString(PyExc_OverflowError, "char not in range");
+        return NULL;
+    }
+
+    PycStringIO->cwrite(self->buffer, (char *)&val, 1);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_ushort(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 2) != 2)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+    return unpack_uint(self, buf, 2);
+}
+
+static PyObject *
+BufferedByteStream_write_ushort(BufferedByteStream *self, PyObject *c)
+{
+    unsigned long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_ulong(c, &val))
+        return NULL;
+    if (val < 0 || val > 65535)
+    {
+        PyErr_SetString(PyExc_OverflowError, "ushort not in range");
+        return NULL;
+    }
+    pack_uint(self, val, 2);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_short(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 2) != 2)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+    return unpack_int(self, buf, 2);
+}
+
+static PyObject *
+BufferedByteStream_write_short(BufferedByteStream *self, PyObject *c)
+{
+    long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_long(c, &val))
+        return NULL;
+    if (val < -32768 || val > 32767)
+    {
+        PyErr_SetString(PyExc_OverflowError, "short not in range");
+        return NULL;
+    }
+    pack_int(self, val, 2);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_ulong(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 4) != 4)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+
+    return unpack_uint(self, buf, 4);
+}
+
+static PyObject *
+BufferedByteStream_write_ulong(BufferedByteStream *self, PyObject *c)
+{
+    unsigned long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_ulong(c, &val))
+        return NULL;
+    pack_uint(self, val, 4);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_long(BufferedByteStream *self)
+{
+    char *buf = NULL;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    PycStringIO->cread(self->buffer, &buf, 4);
+    return unpack_int(self, buf, 4);
+}
+
+static PyObject *
+BufferedByteStream_write_long(BufferedByteStream *self, PyObject *c)
+{
+    long val;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (get_long(c, &val))
+        return NULL;
+
+    pack_int(self, val, 4);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_float(BufferedByteStream *self)
+{
+    float x;
+    char *buf;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 4) != 4)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+
+    switch(self->endian)
+    {
+        case ENDIAN_NATIVE:
+            memcpy((char *)&x, buf, 4);
+            break;
+        case ENDIAN_NETWORK:
+        case ENDIAN_BIG:
+            x = _PyFloat_Unpack4((unsigned char *) buf, 0);
+            break;
+        case ENDIAN_LITTLE:
+            x = _PyFloat_Unpack4((unsigned char *) buf, 1);
+            break;
+    }
+    return PyFloat_FromDouble(x);
+}
+
+static PyObject *
+BufferedByteStream_write_float(BufferedByteStream *self, PyObject *c)
+{
+    char buf[8];
+    double x;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    x = PyFloat_AsDouble(c);
+    if(PyErr_Occurred())
+    {
+        return NULL;
+    }
+
+    switch(self->endian)
+    {
+        case ENDIAN_NATIVE:
+            memcpy(buf, (char *)&x, 4);
+            break;
+        case ENDIAN_NETWORK:
+        case ENDIAN_BIG:
+            _PyFloat_Pack4(x, (unsigned char *) buf, 0);
+            break;
+        case ENDIAN_LITTLE:
+            _PyFloat_Pack4(x, (unsigned char *) buf, 1);
+            break;
+    }
+    PycStringIO->cwrite(self->buffer, (char *)&buf, 4);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+BufferedByteStream_read_double(BufferedByteStream *self)
+{
+    double x;
+    char *buf;
+
+    if(!self->buffer) {
+        PyErr_SetString(PyExc_ValueError, "buffer is closed");
+        return NULL;
+    }
+
+    if (PycStringIO->cread(self->buffer, &buf, 8) != 8)
+    {
+        PyErr_SetNone(PyExc_EOFError);
+        return NULL;
+    }
+
+    switch(self->endian)
+    {
+        case ENDIAN_NATIVE:
+            memcpy((char *)&x, buf, 8);
+            break;
+        case ENDIAN_NETWORK:
+        case ENDIAN_BIG:
+            x = _PyFloat_Unpack8((unsigned char *) buf, 0);
+            break;
+        case ENDIAN_LITTLE:
+            x = _PyFloat_Unpack8((unsigned char *) buf, 1);
+            break;
+    }
+    return PyFloat_FromDouble(x);