#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "bytes_methods.h"

#include <stddef.h>

static Py_ssize_t

_getbuffer(PyObject *obj, Py_buffer *view)

{

PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;

if (buffer == NULL || buffer->bf_getbuffer == NULL)

{

PyErr_Format(PyExc_TypeError,

"Type %.100s doesn't support the buffer API",

Py_TYPE(obj)->tp_name);

return -1;

}

if (buffer->bf_getbuffer(obj, view, PyBUF_SIMPLE) < 0)

return -1;

return view->len;

}

#ifdef COUNT_ALLOCS

Py_ssize_t null_strings, one_strings;

static PyBytesObject *characters[UCHAR_MAX + 1];

static PyBytesObject *nullstring;

#define PyBytesObject_SIZE (offsetof(PyBytesObject, ob_sval) + 1)

PyObject *

PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)

{

register PyBytesObject *op;

if (size < 0) {

PyErr_SetString(PyExc_SystemError,

"Negative size passed to PyBytes_FromStringAndSize");

return NULL;

}

if (size == 0 && (op = nullstring) != NULL) {

#ifdef COUNT_ALLOCS

null_strings++;

Py_INCREF(op);

return (PyObject *)op;

}

if (size == 1 && str != NULL &&

(op = characters[*str & UCHAR_MAX]) != NULL)

{

#ifdef COUNT_ALLOCS

one_strings++;

Py_INCREF(op);

return (PyObject *)op;

}

if (size > PY_SSIZE_T_MAX - PyBytesObject_SIZE) {

PyErr_SetString(PyExc_OverflowError,

"byte string is too large");

return NULL;

}

/* Inline PyObject_NewVar */

op = (PyBytesObject *)PyObject_MALLOC(PyBytesObject_SIZE + size);

if (op == NULL)

return PyErr_NoMemory();

PyObject_INIT_VAR(op, &PyBytes_Type, size);

op->ob_shash = -1;

if (str != NULL)

Py_MEMCPY(op->ob_sval, str, size);

op->ob_sval[size] = '\0';

/* share short strings */

if (size == 0) {

nullstring = op;

Py_INCREF(op);

} else if (size == 1 && str != NULL) {

characters[*str & UCHAR_MAX] = op;

Py_INCREF(op);

}

return (PyObject *) op;

}

PyObject *

PyBytes_FromString(const char *str)

{

register size_t size;

register PyBytesObject *op;

assert(str != NULL);

size = strlen(str);

if (size > PY_SSIZE_T_MAX - PyBytesObject_SIZE) {

PyErr_SetString(PyExc_OverflowError,

"byte string is too long");

return NULL;

}

if (size == 0 && (op = nullstring) != NULL) {

#ifdef COUNT_ALLOCS

null_strings++;

Py_INCREF(op);

return (PyObject *)op;

}

if (size == 1 && (op = characters[*str & UCHAR_MAX]) != NULL) {

#ifdef COUNT_ALLOCS

one_strings++;

Py_INCREF(op);

return (PyObject *)op;

}

/* Inline PyObject_NewVar */

op = (PyBytesObject *)PyObject_MALLOC(PyBytesObject_SIZE + size);

if (op == NULL)

return PyErr_NoMemory();

PyObject_INIT_VAR(op, &PyBytes_Type, size);

op->ob_shash = -1;

Py_MEMCPY(op->ob_sval, str, size+1);

/* share short strings */

if (size == 0) {

nullstring = op;

Py_INCREF(op);

} else if (size == 1) {

characters[*str & UCHAR_MAX] = op;

Py_INCREF(op);

}

return (PyObject *) op;

}

PyObject *

PyBytes_FromFormatV(const char *format, va_list vargs)

{

va_list count;

Py_ssize_t n = 0;

const char* f;

char *s;

PyObject* string;

Py_VA_COPY(count, vargs);

/* step 1: figure out how large a buffer we need */

for (f = format; *f; f++) {

if (*f == '%') {

const char* p = f;

while (*++f && *f != '%' && !Py_ISALPHA(*f))

;

/* skip the 'l' or 'z' in {%ld, %zd, %lu, %zu} since

if ((*f == 'l' || *f == 'z') &&

(f[1] == 'd' || f[1] == 'u'))

++f;

switch (*f) {

case 'c':

(void)va_arg(count, int);

/* fall through... */

case '%':

n++;

break;

case 'd': case 'u': case 'i': case 'x':

(void) va_arg(count, int);

/* 20 bytes is enough to hold a 64-bit

n += 20;

break;

case 's':

s = va_arg(count, char*);

n += strlen(s);

break;

case 'p':

(void) va_arg(count, int);

/* maximum 64-bit pointer representation:

n += 19;

break;

default:

/* if we stumble upon an unknown

n += strlen(p);

goto expand;

}

} else

n++;

}

expand:

/* step 2: fill the buffer */

/* Since we've analyzed how much space we need for the worst case,

string = PyBytes_FromStringAndSize(NULL, n);

if (!string)

return NULL;

s = PyBytes_AsString(string);

for (f = format; *f; f++) {

if (*f == '%') {

const char* p = f++;

Py_ssize_t i;

int longflag = 0;

int size_tflag = 0;

/* parse the width.precision part (we're only

n = 0;

while (Py_ISDIGIT(*f))

n = (n*10) + *f++ - '0';

if (*f == '.') {

f++;

n = 0;

while (Py_ISDIGIT(*f))

n = (n*10) + *f++ - '0';

}

while (*f && *f != '%' && !Py_ISALPHA(*f))

f++;

/* handle the long flag, but only for %ld and %lu.

if (*f == 'l' && (f[1] == 'd' || f[1] == 'u')) {

longflag = 1;

++f;

}

/* handle the size_t flag. */

if (*f == 'z' && (f[1] == 'd' || f[1] == 'u')) {

size_tflag = 1;

++f;

}

switch (*f) {

case 'c':

*s++ = va_arg(vargs, int);

break;

case 'd':

if (longflag)

sprintf(s, "%ld", va_arg(vargs, long));

else if (size_tflag)

sprintf(s, "%" PY_FORMAT_SIZE_T "d",

va_arg(vargs, Py_ssize_t));

else

sprintf(s, "%d", va_arg(vargs, int));

s += strlen(s);

break;

case 'u':

if (longflag)

sprintf(s, "%lu",

va_arg(vargs, unsigned long));

else if (size_tflag)

sprintf(s, "%" PY_FORMAT_SIZE_T "u",

va_arg(vargs, size_t));

else

sprintf(s, "%u",

va_arg(vargs, unsigned int));

s += strlen(s);

break;

case 'i':

sprintf(s, "%i", va_arg(vargs, int));

s += strlen(s);

break;

case 'x':

sprintf(s, "%x", va_arg(vargs, int));

s += strlen(s);

break;

case 's':

p = va_arg(vargs, char*);

i = strlen(p);

if (n > 0 && i > n)

i = n;

Py_MEMCPY(s, p, i);

s += i;

break;

case 'p':

sprintf(s, "%p", va_arg(vargs, void*));

/* %p is ill-defined: ensure leading 0x. */

if (s[1] == 'X')

s[1] = 'x';

else if (s[1] != 'x') {

memmove(s+2, s, strlen(s)+1);

s[0] = '0';

s[1] = 'x';

}

s += strlen(s);

break;

case '%':

*s++ = '%';

break;

default:

strcpy(s, p);

s += strlen(s);

goto end;

}

} else

*s++ = *f;

}

end:

_PyBytes_Resize(&string, s - PyBytes_AS_STRING(string));

return string;

}

PyObject *

PyBytes_FromFormat(const char *format, ...)

{

PyObject* ret;

va_list vargs;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, format);

va_start(vargs);

ret = PyBytes_FromFormatV(format, vargs);

va_end(vargs);

return ret;

}

static void

bytes_dealloc(PyObject *op)

{

Py_TYPE(op)->tp_free(op);

}

PyObject *PyBytes_DecodeEscape(const char *s,

const char *recode_encoding)

{

int c;

char *p, *buf;

const char *end;

PyObject *v;

Py_ssize_t newlen = recode_encoding ? 4*len:len;

v = PyBytes_FromStringAndSize((char *)NULL, newlen);

if (v == NULL)

return NULL;

p = buf = PyBytes_AsString(v);

end = s + len;

while (s < end) {

if (*s != '\\') {

non_esc:

if (recode_encoding && (*s & 0x80)) {

PyObject *u, *w;

char *r;

const char* t;

Py_ssize_t rn;

t = s;

/* Decode non-ASCII bytes as UTF-8. */

while (t < end && (*t & 0x80)) t++;

u = PyUnicode_DecodeUTF8(s, t - s, errors);

if(!u) goto failed;

/* Recode them in target encoding. */

w = PyUnicode_AsEncodedString(

u, recode_encoding, errors);

Py_DECREF(u);

if (!w) goto failed;

/* Append bytes to output buffer. */

assert(PyBytes_Check(w));

r = PyBytes_AS_STRING(w);

rn = PyBytes_GET_SIZE(w);

Py_MEMCPY(p, r, rn);

p += rn;

Py_DECREF(w);

s = t;

} else {

*p++ = *s++;

}

continue;

}

s++;

if (s==end) {

PyErr_SetString(PyExc_ValueError,

"Trailing \\ in string");

goto failed;

}

switch (*s++) {

/* XXX This assumes ASCII! */

case '\n': break;

case '\\': *p++ = '\\'; break;

case '\'': *p++ = '\''; break;

case '\"': *p++ = '\"'; break;

case 'b': *p++ = '\b'; break;

case 'f': *p++ = '\014'; break; /* FF */

case 't': *p++ = '\t'; break;

case 'n': *p++ = '\n'; break;

case 'r': *p++ = '\r'; break;

case 'v': *p++ = '\013'; break; /* VT */

case 'a': *p++ = '\007'; break; /* BEL, not classic C */

case '0': case '1': case '2': case '3':

case '4': case '5': case '6': case '7':

c = s[-1] - '0';

if (s < end && '0' <= *s && *s <= '7') {

c = (c<<3) + *s++ - '0';

if (s < end && '0' <= *s && *s <= '7')

c = (c<<3) + *s++ - '0';

}

*p++ = c;

break;

case 'x':

if (s+1 < end && Py_ISXDIGIT(s[0]) && Py_ISXDIGIT(s[1])) {

unsigned int x = 0;

c = Py_CHARMASK(*s);

s++;

if (Py_ISDIGIT(c))

x = c - '0';

else if (Py_ISLOWER(c))

x = 10 + c - 'a';

else

x = 10 + c - 'A';

x = x << 4;

c = Py_CHARMASK(*s);

s++;

if (Py_ISDIGIT(c))

x += c - '0';

else if (Py_ISLOWER(c))

x += 10 + c - 'a';

else

x += 10 + c - 'A';

*p++ = x;

break;

}

if (!errors || strcmp(errors, "strict") == 0) {

PyErr_Format(PyExc_ValueError,

"invalid \\x escape at position %d",

s - 2 - (end - len));

goto failed;

}

if (strcmp(errors, "replace") == 0) {

*p++ = '?';

} else if (strcmp(errors, "ignore") == 0)

/* do nothing */;

else {

PyErr_Format(PyExc_ValueError,

"decoding error; unknown "

"error handling code: %.400s",

errors);

goto failed;

}

/* skip \x */

if (s < end && Py_ISXDIGIT(s[0]))

s++; /* and a hexdigit */

break;

default:

*p++ = '\\';

s--;

goto non_esc; /* an arbitrary number of unescaped

}

}

if (p-buf < newlen)

_PyBytes_Resize(&v, p - buf);

return v;

failed:

Py_DECREF(v);

return NULL;

}

PyBytes_Size(register PyObject *op)

{

if (!PyBytes_Check(op)) {

PyErr_Format(PyExc_TypeError,

"expected bytes, %.200s found", Py_TYPE(op)->tp_name);

return -1;

}

return Py_SIZE(op);

}

char *

PyBytes_AsString(register PyObject *op)

{

if (!PyBytes_Check(op)) {

PyErr_Format(PyExc_TypeError,

"expected bytes, %.200s found", Py_TYPE(op)->tp_name);

return NULL;

}

return ((PyBytesObject *)op)->ob_sval;

}

PyBytes_AsStringAndSize(register PyObject *obj,

register char **s,

register Py_ssize_t *len)

{

if (s == NULL) {

PyErr_BadInternalCall();

return -1;

}

if (!PyBytes_Check(obj)) {

PyErr_Format(PyExc_TypeError,

"expected bytes, %.200s found", Py_TYPE(obj)->tp_name);

return -1;

}

*s = PyBytes_AS_STRING(obj);

if (len != NULL)

*len = PyBytes_GET_SIZE(obj);

else if (strlen(*s) != (size_t)PyBytes_GET_SIZE(obj)) {

PyErr_SetString(PyExc_TypeError,

"expected bytes with no null");

return -1;

}

return 0;

}

#include "stringlib/stringdefs.h"

#include "stringlib/fastsearch.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/ctype.h"

#include "stringlib/transmogrify.h"

PyObject *

PyBytes_Repr(PyObject *obj, int smartquotes)

{

static const char *hexdigits = "0123456789abcdef";

register PyBytesObject* op = (PyBytesObject*) obj;

Py_ssize_t length = Py_SIZE(op);

size_t newsize;

PyObject *v;

if (length > (PY_SSIZE_T_MAX - 3) / 4) {

PyErr_SetString(PyExc_OverflowError,

"bytes object is too large to make repr");

return NULL;

}

newsize = 3 + 4 * length;

v = PyUnicode_FromUnicode(NULL, newsize);

if (v == NULL) {

return NULL;

}

else {

register Py_ssize_t i;

register Py_UNICODE c;

register Py_UNICODE *p = PyUnicode_AS_UNICODE(v);

int quote;

/* Figure out which quote to use; single is preferred */

quote = '\'';

if (smartquotes) {

char *test, *start;

start = PyBytes_AS_STRING(op);

for (test = start; test < start+length; ++test) {

if (*test == '"') {

quote = '\''; /* back to single */

goto decided;

}

else if (*test == '\'')

quote = '"';

}

decided:

;

}

*p++ = 'b', *p++ = quote;

for (i = 0; i < length; i++) {

/* There's at least enough room for a hex escape

assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);

c = op->ob_sval[i];

if (c == quote || c == '\\')

*p++ = '\\', *p++ = c;

else if (c == '\t')

*p++ = '\\', *p++ = 't';

else if (c == '\n')

*p++ = '\\', *p++ = 'n';

else if (c == '\r')

*p++ = '\\', *p++ = 'r';

else if (c < ' ' || c >= 0x7f) {

*p++ = '\\';

*p++ = 'x';

*p++ = hexdigits[(c & 0xf0) >> 4];

*p++ = hexdigits[c & 0xf];

}

else

*p++ = c;

}

assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);

*p++ = quote;

*p = '\0';

if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {

Py_DECREF(v);

return NULL;

}

return v;

}

}

static PyObject *

bytes_repr(PyObject *op)

{

return PyBytes_Repr(op, 1);

}

static PyObject *

bytes_str(PyObject *op)

{

if (Py_BytesWarningFlag) {

if (PyErr_WarnEx(PyExc_BytesWarning,

"str() on a bytes instance", 1))

return NULL;

}

return bytes_repr(op);

}

static Py_ssize_t

bytes_length(PyBytesObject *a)

{

return Py_SIZE(a);

}

static PyObject *

bytes_concat(PyObject *a, PyObject *b)

{

Py_ssize_t size;

Py_buffer va, vb;

PyObject *result = NULL;

va.len = -1;

vb.len = -1;

if (_getbuffer(a, &va) < 0 ||

_getbuffer(b, &vb) < 0) {

PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);

goto done;

}

/* Optimize end cases */

if (va.len == 0 && PyBytes_CheckExact(b)) {

result = b;

Py_INCREF(result);

goto done;

}

if (vb.len == 0 && PyBytes_CheckExact(a)) {

result = a;

Py_INCREF(result);

goto done;

}

size = va.len + vb.len;

if (size < 0) {

PyErr_NoMemory();

goto done;

}

result = PyBytes_FromStringAndSize(NULL, size);

if (result != NULL) {

memcpy(PyBytes_AS_STRING(result), va.buf, va.len);

memcpy(PyBytes_AS_STRING(result) + va.len, vb.buf, vb.len);

}

done:

if (va.len != -1)

PyBuffer_Release(&va);

if (vb.len != -1)

PyBuffer_Release(&vb);

return result;

}

static PyObject *

bytes_repeat(register PyBytesObject *a, register Py_ssize_t n)

{

register Py_ssize_t i;

register Py_ssize_t j;

register Py_ssize_t size;

register PyBytesObject *op;

size_t nbytes;

if (n < 0)

n = 0;

/* watch out for overflows: the size can overflow int,

if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n) {

PyErr_SetString(PyExc_OverflowError,

"repeated bytes are too long");

return NULL;

}

size = Py_SIZE(a) * n;

if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {

Py_INCREF(a);

return (PyObject *)a;

}

nbytes = (size_t)size;

if (nbytes + PyBytesObject_SIZE <= nbytes) {

PyErr_SetString(PyExc_OverflowError,

"repeated bytes are too long");

return NULL;

}

op = (PyBytesObject *)PyObject_MALLOC(PyBytesObject_SIZE + nbytes);

if (op == NULL)

return PyErr_NoMemory();

PyObject_INIT_VAR(op, &PyBytes_Type, size);

op->ob_shash = -1;

op->ob_sval[size] = '\0';

if (Py_SIZE(a) == 1 && n > 0) {

memset(op->ob_sval, a->ob_sval[0] , n);

return (PyObject *) op;

}

i = 0;

if (i < size) {

Py_MEMCPY(op->ob_sval, a->ob_sval, Py_SIZE(a));

i = Py_SIZE(a);

}

while (i < size) {

j = (i <= size-i) ? i : size-i;

Py_MEMCPY(op->ob_sval+i, op->ob_sval, j);

i += j;

}

return (PyObject *) op;

}

static int

bytes_contains(PyObject *self, PyObject *arg)

{

Py_ssize_t ival = PyNumber_AsSsize_t(arg, PyExc_ValueError);

if (ival == -1 && PyErr_Occurred()) {

Py_buffer varg;

Py_ssize_t pos;

PyErr_Clear();

if (_getbuffer(arg, &varg) < 0)

return -1;

pos = stringlib_find(PyBytes_AS_STRING(self), Py_SIZE(self),

varg.buf, varg.len, 0);

PyBuffer_Release(&varg);

return pos >= 0;

}

if (ival < 0 || ival >= 256) {

PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");

return -1;

}

return memchr(PyBytes_AS_STRING(self), (int) ival, Py_SIZE(self)) != NULL;

}

static PyObject *

bytes_item(PyBytesObject *a, register Py_ssize_t i)

{

if (i < 0 || i >= Py_SIZE(a)) {

PyErr_SetString(PyExc_IndexError, "index out of range");

return NULL;

}

return PyLong_FromLong((unsigned char)a->ob_sval[i]);

}

static PyObject*

bytes_richcompare(PyBytesObject *a, PyBytesObject *b, int op)

{

int c;

Py_ssize_t len_a, len_b;

Py_ssize_t min_len;

PyObject *result;

/* Make sure both arguments are strings. */

if (!(PyBytes_Check(a) && PyBytes_Check(b))) {

if (Py_BytesWarningFlag && (op == Py_EQ || op == Py_NE) &&

(PyObject_IsInstance((PyObject*)a,

(PyObject*)&PyUnicode_Type) ||

PyObject_IsInstance((PyObject*)b,

(PyObject*)&PyUnicode_Type))) {

if (PyErr_WarnEx(PyExc_BytesWarning,

"Comparison between bytes and string", 1))

return NULL;

}

result = Py_NotImplemented;

goto out;

}

if (a == b) {

switch (op) {

case Py_EQ:case Py_LE:case Py_GE:

result = Py_True;

goto out;

case Py_NE:case Py_LT:case Py_GT:

result = Py_False;

goto out;

}

}

if (op == Py_EQ) {

/* Supporting Py_NE here as well does not save

if (Py_SIZE(a) == Py_SIZE(b)

&& (a->ob_sval[0] == b->ob_sval[0]

&& memcmp(a->ob_sval, b->ob_sval, Py_SIZE(a)) == 0)) {

result = Py_True;

} else {

result = Py_False;

}

goto out;

}

len_a = Py_SIZE(a); len_b = Py_SIZE(b);

min_len = (len_a < len_b) ? len_a : len_b;

if (min_len > 0) {

c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);

if (c==0)

c = memcmp(a->ob_sval, b->ob_sval, min_len);

} else

c = 0;

if (c == 0)

c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;

switch (op) {

case Py_LT: c = c < 0; break;

case Py_LE: c = c <= 0; break;

case Py_EQ: assert(0); break; /* unreachable */

case Py_NE: c = c != 0; break;

case Py_GT: c = c > 0; break;

case Py_GE: c = c >= 0; break;

default:

result = Py_NotImplemented;

goto out;

}

result = c ? Py_True : Py_False;

out:

Py_INCREF(result);

return result;

}

static Py_hash_t

bytes_hash(PyBytesObject *a)

{

register Py_ssize_t len;

register unsigned char *p;

register Py_uhash_t x; /* Unsigned for defined overflow behavior. */

#ifdef Py_DEBUG

assert(_Py_HashSecret_Initialized);

if (a->ob_shash != -1)

return a->ob_shash;

len = Py_SIZE(a);

/*

if (len == 0) {

a->ob_shash = 0;

return 0;

}

p = (unsigned char *) a->ob_sval;

x = _Py_HashSecret.prefix;

x ^= *p << 7;

while (--len >= 0)

x = (_PyHASH_MULTIPLIER*x) ^ *p++;

x ^= Py_SIZE(a);

x ^= _Py_HashSecret.suffix;

if (x == -1)

x = -2;

a->ob_shash = x;

return x;

}

static PyObject*

bytes_subscript(PyBytesObject* self, PyObject* item)

{

if (PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

if (i == -1 && PyErr_Occurred())

return NULL;

if (i < 0)

i += PyBytes_GET_SIZE(self);

if (i < 0 || i >= PyBytes_GET_SIZE(self)) {

PyErr_SetString(PyExc_IndexError,

"index out of range");

return NULL;

}

return PyLong_FromLong((unsigned char)self->ob_sval[i]);

}

else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelength, cur, i;

char* source_buf;

char* result_buf;

PyObject* result;

if (PySlice_GetIndicesEx(item,

PyBytes_GET_SIZE(self),

&start, &stop, &step, &slicelength) < 0) {

return NULL;

}

if (slicelength <= 0) {

return PyBytes_FromStringAndSize("", 0);

}

else if (start == 0 && step == 1 &&

slicelength == PyBytes_GET_SIZE(self) &&

PyBytes_CheckExact(self)) {

Py_INCREF(self);

return (PyObject *)self;

}

else if (step == 1) {

return PyBytes_FromStringAndSize(

PyBytes_AS_STRING(self) + start,

slicelength);

}

else {

source_buf = PyBytes_AS_STRING(self);

result = PyBytes_FromStringAndSize(NULL, slicelength);

if (result == NULL)

return NULL;

result_buf = PyBytes_AS_STRING(result);

for (cur = start, i = 0; i < slicelength;

cur += step, i++) {

result_buf[i] = source_buf[cur];

}

return result;

}

}

else {

PyErr_Format(PyExc_TypeError,

"byte indices must be integers, not %.200s",

Py_TYPE(item)->tp_name);

return NULL;

}

}

static int

bytes_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags)

{

return PyBuffer_FillInfo(view, (PyObject*)self, (void *)self->ob_sval, Py_SIZE(self),

1, flags);

}

static PySequenceMethods bytes_as_sequence = {

(lenfunc)bytes_length, /*sq_length*/

(binaryfunc)bytes_concat, /*sq_concat*/

(ssizeargfunc)bytes_repeat, /*sq_repeat*/

(ssizeargfunc)bytes_item, /*sq_item*/

0, /*sq_slice*/

0, /*sq_ass_item*/

0, /*sq_ass_slice*/

(objobjproc)bytes_contains /*sq_contains*/

};

static PyMappingMethods bytes_as_mapping = {

(lenfunc)bytes_length,

(binaryfunc)bytes_subscript,

0,

};

static PyBufferProcs bytes_as_buffer = {

(getbufferproc)bytes_buffer_getbuffer,