/* bytes object implementation */

#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 *bufferprocs;

if (PyBytes_CheckExact(obj)) {

/* Fast path, e.g. for .join() of many bytes objects */

Py_INCREF(obj);

view->obj = obj;

view->buf = PyBytes_AS_STRING(obj);

view->len = PyBytes_GET_SIZE(obj);

return view->len;

}

bufferprocs = Py_TYPE(obj)->tp_as_buffer;

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

{

PyErr_Format(PyExc_TypeError,

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

Py_TYPE(obj)->tp_name);

return -1;

}

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

return -1;

return view->len;

}

#ifdef COUNT_ALLOCS

Py_ssize_t null_strings, one_strings;

#endif

static PyBytesObject *characters[UCHAR_MAX + 1];

static PyBytesObject *nullstring;

/* PyBytesObject_SIZE gives the basic size of a string; any memory allocation

for a string of length n should request PyBytesObject_SIZE + n bytes.

Using PyBytesObject_SIZE instead of sizeof(PyBytesObject) saves

3 bytes per string allocation on a typical system.

*/

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

/*

For PyBytes_FromString(), the parameter `str' points to a null-terminated

string containing exactly `size' bytes.

For PyBytes_FromStringAndSize(), the parameter the parameter `str' is

either NULL or else points to a string containing at least `size' bytes.

For PyBytes_FromStringAndSize(), the string in the `str' parameter does

not have to be null-terminated. (Therefore it is safe to construct a

substring by calling `PyBytes_FromStringAndSize(origstring, substrlen)'.)

If `str' is NULL then PyBytes_FromStringAndSize() will allocate `size+1'

bytes (setting the last byte to the null terminating character) and you can

fill in the data yourself. If `str' is non-NULL then the resulting

PyBytes object must be treated as immutable and you must not fill in nor

alter the data yourself, since the strings may be shared.

The PyObject member `op->ob_size', which denotes the number of "extra

items" in a variable-size object, will contain the number of bytes

allocated for string data, not counting the null terminating character.

It is therefore equal to the `size' parameter (for

PyBytes_FromStringAndSize()) or the length of the string in the `str'

parameter (for PyBytes_FromString()).

*/

static PyObject *

_PyBytes_FromSize(Py_ssize_t size, int use_calloc)

{

PyBytesObject *op;

assert(size >= 0);

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

#ifdef COUNT_ALLOCS

null_strings++;

#endif

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 */

if (use_calloc)

op = (PyBytesObject *)PyObject_Calloc(1, PyBytesObject_SIZE + size);

else

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

if (op == NULL)

return PyErr_NoMemory();

(void)PyObject_INIT_VAR(op, &PyBytes_Type, size);

op->ob_shash = -1;

if (!use_calloc)

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

/* empty byte string singleton */

if (size == 0) {

nullstring = op;

Py_INCREF(op);

}

return (PyObject *) op;

}

PyObject *

PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)

{

PyBytesObject *op;

if (size < 0) {

PyErr_SetString(PyExc_SystemError,

"Negative size passed to PyBytes_FromStringAndSize");

return NULL;

}

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

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

{

#ifdef COUNT_ALLOCS

one_strings++;

#endif

Py_INCREF(op);

return (PyObject *)op;

}

op = (PyBytesObject *)_PyBytes_FromSize(size, 0);

if (op == NULL)

return NULL;

if (str == NULL)

return (PyObject *) op;

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

/* share short strings */

if (size == 1) {

characters[*str & UCHAR_MAX] = op;

Py_INCREF(op);

}

return (PyObject *) op;

}

PyObject *

PyBytes_FromString(const char *str)

{

size_t size;

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++;

#endif

Py_INCREF(op);

return (PyObject *)op;

}

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

#ifdef COUNT_ALLOCS

one_strings++;

#endif

Py_INCREF(op);

return (PyObject *)op;

}

/* Inline PyObject_NewVar */

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

if (op == NULL)

return PyErr_NoMemory();

(void)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

* they don't affect the amount of space we reserve.

*/

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

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

++f;

switch (*f) {

case 'c':

{

int c = va_arg(count, int);

if (c < 0 || c > 255) {

PyErr_SetString(PyExc_OverflowError,

"PyBytes_FromFormatV(): %c format "

"expects an integer in range [0; 255]");

return NULL;

}

n++;

break;

}

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

integer. Decimal takes the most space.

This isn't enough for octal. */

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:

* 0xffffffffffffffff

* so 19 characters is enough.

* XXX I count 18 -- what's the extra for?

*/

n += 19;

break;

default:

/* if we stumble upon an unknown

formatting code, copy the rest of

the format string to the output

string. (we cannot just skip the

code, since there's no way to know

what's in the argument list) */

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,

use sprintf directly instead of the slower PyOS_snprintf. */

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

interested in the precision value, if any) */

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.

others can be added when necessary. */

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':

{

int c = va_arg(vargs, int);

/* c has been checked for overflow in the first step */

*s++ = (unsigned char)c;

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);

#else

va_start(vargs);

#endif

ret = PyBytes_FromFormatV(format, vargs);

va_end(vargs);

return ret;

}

static void

bytes_dealloc(PyObject *op)

{

Py_TYPE(op)->tp_free(op);

}

/* Unescape a backslash-escaped string. If unicode is non-zero,

the string is a u-literal. If recode_encoding is non-zero,

the string is UTF-8 encoded and should be re-encoded in the

specified encoding. */

PyObject *PyBytes_DecodeEscape(const char *s,

Py_ssize_t len,

const char *errors,

Py_ssize_t unicode,

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

UTF-8 bytes may follow. */

}

}

if (p-buf < newlen)

_PyBytes_Resize(&v, p - buf);

return v;

failed:

Py_DECREF(v);

return NULL;

}

/* -------------------------------------------------------------------- */

/* object api */

Py_ssize_t

PyBytes_Size(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(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;

}

int

PyBytes_AsStringAndSize(PyObject *obj,

char **s,

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;

}

/* -------------------------------------------------------------------- */

/* Methods */

#include "stringlib/stringdefs.h"

#include "stringlib/fastsearch.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/join.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/ctype.h"

#include "stringlib/transmogrify.h"

PyObject *

PyBytes_Repr(PyObject *obj, int smartquotes)

{

PyBytesObject* op = (PyBytesObject*) obj;

Py_ssize_t i, length = Py_SIZE(op);

size_t newsize, squotes, dquotes;

PyObject *v;

unsigned char quote, *s, *p;

/* Compute size of output string */

squotes = dquotes = 0;

newsize = 3; /* b'' */

s = (unsigned char*)op->ob_sval;

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

switch(s[i]) {

case '\'': squotes++; newsize++; break;

case '"': dquotes++; newsize++; break;

case '\\': case '\t': case '\n': case '\r':

newsize += 2; break; /* \C */

default:

if (s[i] < ' ' || s[i] >= 0x7f)

newsize += 4; /* \xHH */

else

newsize++;

}

}

quote = '\'';

if (smartquotes && squotes && !dquotes)

quote = '"';

if (squotes && quote == '\'')

newsize += squotes;

if (newsize > (PY_SSIZE_T_MAX - sizeof(PyUnicodeObject) - 1)) {

PyErr_SetString(PyExc_OverflowError,

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

return NULL;

}

v = PyUnicode_New(newsize, 127);

if (v == NULL) {

return NULL;

}

p = PyUnicode_1BYTE_DATA(v);

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

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

unsigned char 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++ = Py_hexdigits[(c & 0xf0) >> 4];

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

}

else

*p++ = c;

}

*p++ = quote;

assert(_PyUnicode_CheckConsistency(v, 1));

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);

}

/* This is also used by PyBytes_Concat() */

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(PyBytesObject *a, Py_ssize_t n)

{

Py_ssize_t i;

Py_ssize_t j;

Py_ssize_t size;

PyBytesObject *op;

size_t nbytes;

if (n < 0)

n = 0;

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

* and the # of bytes needed can overflow size_t

*/

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();

(void)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, 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]);

}

Py_LOCAL(int)

bytes_compare_eq(PyBytesObject *a, PyBytesObject *b)

{

int cmp;

Py_ssize_t len;

len = Py_SIZE(a);

if (Py_SIZE(b) != len)

return 0;

if (a->ob_sval[0] != b->ob_sval[0])

return 0;

cmp = memcmp(a->ob_sval, b->ob_sval, len);

return (cmp == 0);

}

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;

}

else if (a == b) {

switch (op) {

case Py_EQ:

case Py_LE:

case Py_GE:

/* a string is equal to itself */

result = Py_True;

break;

case Py_NE:

case Py_LT:

case Py_GT:

result = Py_False;

break;

default:

PyErr_BadArgument();

return NULL;

}

}

else if (op == Py_EQ || op == Py_NE) {

int eq = bytes_compare_eq(a, b);

eq ^= (op == Py_NE);

result = eq ? Py_True : Py_False;

}

else {

len_a = Py_SIZE(a);

len_b = Py_SIZE(b);

min_len = Py_MIN(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_GT: c = c > 0; break;

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

default:

PyErr_BadArgument();

return NULL;

}

result = c ? Py_True : Py_False;

}

Py_INCREF(result);

return result;

}

static Py_hash_t

bytes_hash(PyBytesObject *a)

{

if (a->ob_shash == -1) {

/* Can't fail */

a->ob_shash = _Py_HashBytes(a->ob_sval, Py_SIZE(a));

}

return a->ob_shash;

}

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;

}