#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "bytes_methods.h"

#include "pystrhex.h"

#include <stddef.h>

#include "clinic/bytesobject.c.h"

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

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

Py_INCREF(op);

return (PyObject *)op;

}

if ((size_t)size > (size_t)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++;

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

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

(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

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

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

{

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

va_start(vargs);

ret = PyBytes_FromFormatV(format, vargs);

va_end(vargs);

return ret;

}

Py_LOCAL_INLINE(PyObject *)

getnextarg(PyObject *args, Py_ssize_t arglen, Py_ssize_t *p_argidx)

{

Py_ssize_t argidx = *p_argidx;

if (argidx < arglen) {

(*p_argidx)++;

if (arglen < 0)

return args;

else

return PyTuple_GetItem(args, argidx);

}

PyErr_SetString(PyExc_TypeError,

"not enough arguments for format string");

return NULL;

}

#define F_LJUST (1<<0)

#define F_SIGN (1<<1)

#define F_BLANK (1<<2)

#define F_ALT (1<<3)

#define F_ZERO (1<<4)

static PyObject *

formatfloat(PyObject *v, int flags, int prec, int type)

{

char *p;

PyObject *result;

double x;

x = PyFloat_AsDouble(v);

if (x == -1.0 && PyErr_Occurred()) {

PyErr_Format(PyExc_TypeError, "float argument required, "

"not %.200s", Py_TYPE(v)->tp_name);

return NULL;

}

if (prec < 0)

prec = 6;

p = PyOS_double_to_string(x, type, prec,

(flags & F_ALT) ? Py_DTSF_ALT : 0, NULL);

if (p == NULL)

return NULL;

result = PyBytes_FromStringAndSize(p, strlen(p));

PyMem_Free(p);

return result;

}

static PyObject *

formatlong(PyObject *v, int flags, int prec, int type)

{

PyObject *result, *iobj;

if (type == 'i')

type = 'd';

if (PyLong_Check(v))

return _PyUnicode_FormatLong(v, flags & F_ALT, prec, type);

if (PyNumber_Check(v)) {

/* make sure number is a type of integer for o, x, and X */

if (type == 'o' || type == 'x' || type == 'X')

iobj = PyNumber_Index(v);

else

iobj = PyNumber_Long(v);

if (iobj == NULL) {

if (!PyErr_ExceptionMatches(PyExc_TypeError))

return NULL;

}

else if (!PyLong_Check(iobj))

Py_CLEAR(iobj);

if (iobj != NULL) {

result = _PyUnicode_FormatLong(iobj, flags & F_ALT, prec, type);

Py_DECREF(iobj);

return result;

}

}

PyErr_Format(PyExc_TypeError,

"%%%c format: %s is required, not %.200s", type,

(type == 'o' || type == 'x' || type == 'X') ? "an integer"

: "a number",

Py_TYPE(v)->tp_name);

return NULL;

}

static int

byte_converter(PyObject *arg, char *p)

{

if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1) {

*p = PyBytes_AS_STRING(arg)[0];

return 1;

}

else if (PyByteArray_Check(arg) && PyByteArray_Size(arg) == 1) {

*p = PyByteArray_AS_STRING(arg)[0];

return 1;

}

else {

PyObject *iobj;

long ival;

int overflow;

/* make sure number is a type of integer */

if (PyLong_Check(arg)) {

ival = PyLong_AsLongAndOverflow(arg, &overflow);

}

else {

iobj = PyNumber_Index(arg);

if (iobj == NULL) {

if (!PyErr_ExceptionMatches(PyExc_TypeError))

return 0;

goto onError;

}

ival = PyLong_AsLongAndOverflow(iobj, &overflow);

Py_DECREF(iobj);

}

if (!overflow && ival == -1 && PyErr_Occurred())

goto onError;

if (overflow || !(0 <= ival && ival <= 255)) {

PyErr_SetString(PyExc_OverflowError,

"%c arg not in range(256)");

return 0;

}

*p = (char)ival;

return 1;

}

onError:

PyErr_SetString(PyExc_TypeError,

"%c requires an integer in range(256) or a single byte");

return 0;

}

static PyObject *

format_obj(PyObject *v, const char **pbuf, Py_ssize_t *plen)

{

PyObject *func, *result;

_Py_IDENTIFIER(__bytes__);

/* is it a bytes object? */

if (PyBytes_Check(v)) {

*pbuf = PyBytes_AS_STRING(v);

*plen = PyBytes_GET_SIZE(v);

Py_INCREF(v);

return v;

}

if (PyByteArray_Check(v)) {

*pbuf = PyByteArray_AS_STRING(v);

*plen = PyByteArray_GET_SIZE(v);

Py_INCREF(v);

return v;

}

/* does it support __bytes__? */

func = _PyObject_LookupSpecial(v, &PyId___bytes__);

if (func != NULL) {

result = PyObject_CallFunctionObjArgs(func, NULL);

Py_DECREF(func);

if (result == NULL)

return NULL;

if (!PyBytes_Check(result)) {

PyErr_Format(PyExc_TypeError,

"__bytes__ returned non-bytes (type %.200s)",

Py_TYPE(result)->tp_name);

Py_DECREF(result);

return NULL;

}

*pbuf = PyBytes_AS_STRING(result);

*plen = PyBytes_GET_SIZE(result);

return result;

}

PyErr_Format(PyExc_TypeError,

"%%b requires bytes, or an object that implements __bytes__, not '%.100s'",

Py_TYPE(v)->tp_name);

return NULL;

}

#define FORMATBUFLEN (size_t)120

PyObject *

_PyBytes_Format(PyObject *format, PyObject *args)

{

char *fmt, *res;

Py_ssize_t arglen, argidx;

Py_ssize_t reslen, rescnt, fmtcnt;

int args_owned = 0;

PyObject *result;

PyObject *dict = NULL;

if (format == NULL || !PyBytes_Check(format) || args == NULL) {

PyErr_BadInternalCall();

return NULL;

}

fmt = PyBytes_AS_STRING(format);

fmtcnt = PyBytes_GET_SIZE(format);

reslen = rescnt = fmtcnt + 100;

result = PyBytes_FromStringAndSize((char *)NULL, reslen);

if (result == NULL)

return NULL;

res = PyBytes_AsString(result);

if (PyTuple_Check(args)) {

arglen = PyTuple_GET_SIZE(args);

argidx = 0;

}

else {

arglen = -1;

argidx = -2;

}

if (Py_TYPE(args)->tp_as_mapping && Py_TYPE(args)->tp_as_mapping->mp_subscript &&

!PyTuple_Check(args) && !PyBytes_Check(args) && !PyUnicode_Check(args) &&

!PyByteArray_Check(args)) {

dict = args;

}

while (--fmtcnt >= 0) {

if (*fmt != '%') {

if (--rescnt < 0) {

rescnt = fmtcnt + 100;

reslen += rescnt;

if (_PyBytes_Resize(&result, reslen))

return NULL;

res = PyBytes_AS_STRING(result)

+ reslen - rescnt;

--rescnt;

}

*res++ = *fmt++;

}

else {

/* Got a format specifier */

int flags = 0;

Py_ssize_t width = -1;

int prec = -1;

int c = '\0';

int fill;

PyObject *v = NULL;

PyObject *temp = NULL;

const char *pbuf = NULL;

int sign;

Py_ssize_t len = 0;

char onechar; /* For byte_converter() */

fmt++;

if (*fmt == '(') {

char *keystart;

Py_ssize_t keylen;

PyObject *key;

int pcount = 1;

if (dict == NULL) {

PyErr_SetString(PyExc_TypeError,

"format requires a mapping");

goto error;

}

++fmt;

--fmtcnt;

keystart = fmt;

/* Skip over balanced parentheses */

while (pcount > 0 && --fmtcnt >= 0) {

if (*fmt == ')')

--pcount;

else if (*fmt == '(')

++pcount;

fmt++;

}

keylen = fmt - keystart - 1;

if (fmtcnt < 0 || pcount > 0) {

PyErr_SetString(PyExc_ValueError,

"incomplete format key");

goto error;

}

key = PyBytes_FromStringAndSize(keystart,

keylen);

if (key == NULL)

goto error;

if (args_owned) {

Py_DECREF(args);

args_owned = 0;

}

args = PyObject_GetItem(dict, key);

Py_DECREF(key);

if (args == NULL) {

goto error;

}

args_owned = 1;

arglen = -1;

argidx = -2;

}

while (--fmtcnt >= 0) {

switch (c = *fmt++) {

case '-': flags |= F_LJUST; continue;

case '+': flags |= F_SIGN; continue;

case ' ': flags |= F_BLANK; continue;

case '#': flags |= F_ALT; continue;

case '0': flags |= F_ZERO; continue;

}

break;

}

if (c == '*') {

v = getnextarg(args, arglen, &argidx);

if (v == NULL)

goto error;

if (!PyLong_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"* wants int");

goto error;

}

width = PyLong_AsSsize_t(v);

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

goto error;

if (width < 0) {

flags |= F_LJUST;

width = -width;

}

if (--fmtcnt >= 0)

c = *fmt++;

}

else if (c >= 0 && isdigit(c)) {

width = c - '0';

while (--fmtcnt >= 0) {

c = Py_CHARMASK(*fmt++);

if (!isdigit(c))

break;

if (width > (PY_SSIZE_T_MAX - ((int)c - '0')) / 10) {

PyErr_SetString(

PyExc_ValueError,

"width too big");

goto error;

}

width = width*10 + (c - '0');

}

}

if (c == '.') {

prec = 0;

if (--fmtcnt >= 0)

c = *fmt++;

if (c == '*') {

v = getnextarg(args, arglen, &argidx);

if (v == NULL)

goto error;

if (!PyLong_Check(v)) {

PyErr_SetString(

PyExc_TypeError,

"* wants int");

goto error;

}

prec = _PyLong_AsInt(v);

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

goto error;

if (prec < 0)

prec = 0;

if (--fmtcnt >= 0)

c = *fmt++;

}

else if (c >= 0 && isdigit(c)) {

prec = c - '0';

while (--fmtcnt >= 0) {

c = Py_CHARMASK(*fmt++);

if (!isdigit(c))

break;

if (prec > (INT_MAX - ((int)c - '0')) / 10) {

PyErr_SetString(

PyExc_ValueError,

"prec too big");

goto error;

}

prec = prec*10 + (c - '0');

}

}

} /* prec */

if (fmtcnt >= 0) {

if (c == 'h' || c == 'l' || c == 'L') {

if (--fmtcnt >= 0)

c = *fmt++;

}

}

if (fmtcnt < 0) {

PyErr_SetString(PyExc_ValueError,

"incomplete format");

goto error;

}

if (c != '%') {

v = getnextarg(args, arglen, &argidx);

if (v == NULL)

goto error;

}

sign = 0;

fill = ' ';

switch (c) {

case '%':

pbuf = "%";

len = 1;

break;

case 'r':

// %r is only for 2/3 code; 3 only code should use %a

case 'a':

temp = PyObject_ASCII(v);

if (temp == NULL)

goto error;

assert(PyUnicode_IS_ASCII(temp));

pbuf = (const char *)PyUnicode_1BYTE_DATA(temp);

len = PyUnicode_GET_LENGTH(temp);

if (prec >= 0 && len > prec)

len = prec;

break;

case 's':

// %s is only for 2/3 code; 3 only code should use %b

case 'b':

temp = format_obj(v, &pbuf, &len);

if (temp == NULL)

goto error;

if (prec >= 0 && len > prec)

len = prec;

break;

case 'i':

case 'd':

case 'u':

case 'o':

case 'x':

case 'X':

temp = formatlong(v, flags, prec, c);

if (!temp)

goto error;

assert(PyUnicode_IS_ASCII(temp));

pbuf = (const char *)PyUnicode_1BYTE_DATA(temp);

len = PyUnicode_GET_LENGTH(temp);

sign = 1;

if (flags & F_ZERO)

fill = '0';

break;

case 'e':

case 'E':

case 'f':

case 'F':

case 'g':

case 'G':

temp = formatfloat(v, flags, prec, c);

if (temp == NULL)

goto error;

pbuf = PyBytes_AS_STRING(temp);

len = PyBytes_GET_SIZE(temp);

sign = 1;

if (flags & F_ZERO)

fill = '0';

break;

case 'c':

pbuf = &onechar;

len = byte_converter(v, &onechar);

if (!len)

goto error;

break;

default:

PyErr_Format(PyExc_ValueError,

"unsupported format character '%c' (0x%x) "

"at index %zd",

c, c,

(Py_ssize_t)(fmt - 1 -

PyBytes_AsString(format)));

goto error;

}

if (sign) {

if (*pbuf == '-' || *pbuf == '+') {

sign = *pbuf++;

len--;

}

else if (flags & F_SIGN)

sign = '+';

else if (flags & F_BLANK)

sign = ' ';

else

sign = 0;

}

if (width < len)

width = len;

if (rescnt - (sign != 0) < width) {

reslen -= rescnt;

rescnt = width + fmtcnt + 100;

reslen += rescnt;

if (reslen < 0) {

Py_DECREF(result);

Py_XDECREF(temp);

return PyErr_NoMemory();

}

if (_PyBytes_Resize(&result, reslen)) {

Py_XDECREF(temp);

return NULL;

}

res = PyBytes_AS_STRING(result)

+ reslen - rescnt;

}

if (sign) {

if (fill != ' ')

*res++ = sign;

rescnt--;

if (width > len)

width--;

}

if ((flags & F_ALT) && (c == 'o' || c == 'x' || c == 'X')) {

assert(pbuf[0] == '0');

assert(pbuf[1] == c);

if (fill != ' ') {

*res++ = *pbuf++;

*res++ = *pbuf++;

}

rescnt -= 2;

width -= 2;

if (width < 0)

width = 0;

len -= 2;

}

if (width > len && !(flags & F_LJUST)) {

do {

--rescnt;

*res++ = fill;

} while (--width > len);

}

if (fill == ' ') {

if (sign)

*res++ = sign;

if ((flags & F_ALT) && (c == 'o' || c == 'x' || c == 'X')) {

assert(pbuf[0] == '0');

assert(pbuf[1] == c);

*res++ = *pbuf++;

*res++ = *pbuf++;

}

}

Py_MEMCPY(res, pbuf, len);

res += len;

rescnt -= len;

while (--width >= len) {

--rescnt;

*res++ = ' ';

}

if (dict && (argidx < arglen) && c != '%') {

PyErr_SetString(PyExc_TypeError,

"not all arguments converted during bytes formatting");

Py_XDECREF(temp);

goto error;

}

Py_XDECREF(temp);

} /* '%' */

} /* until end */

if (argidx < arglen && !dict) {

PyErr_SetString(PyExc_TypeError,

"not all arguments converted during bytes formatting");

goto error;

}

if (args_owned) {

Py_DECREF(args);

}

if (_PyBytes_Resize(&result, reslen - rescnt))

return NULL;

return result;

error:

Py_DECREF(result);

if (args_owned) {

Py_DECREF(args);

}

return NULL;

}

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