#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_bytesobject.h" // _PyBytes_Find(), _PyBytes_Repeat()

#include "pycore_bytes_methods.h" // _Py_bytes_startswith()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_format.h" // F_LJUST

#include "pycore_global_objects.h" // _Py_GET_GLOBAL_OBJECT()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_long.h" // _PyLong_DigitValue

#include "pycore_object.h" // _PyObject_GC_TRACK

#include "pycore_pymem.h" // PYMEM_CLEANBYTE

#include "pycore_strhex.h" // _Py_strhex_with_sep()

#include <stddef.h>

#include "clinic/bytesobject.c.h"

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

Py_LOCAL_INLINE(Py_ssize_t) _PyBytesWriter_GetSize(_PyBytesWriter *writer,

char *str);

#define CHARACTERS _Py_SINGLETON(bytes_characters)

#define CHARACTER(ch) \

((PyBytesObject *)&(CHARACTERS[ch]));

#define EMPTY (&_Py_SINGLETON(bytes_empty))

static inline PyObject* bytes_get_empty(void)

{

return &EMPTY->ob_base.ob_base;

}

static inline PyObject* bytes_new_empty(void)

{

return Py_NewRef(EMPTY);

}

static PyObject *

_PyBytes_FromSize(Py_ssize_t size, int use_calloc)

{

PyBytesObject *op;

assert(size >= 0);

if (size == 0) {

return bytes_new_empty();

}

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

}

_PyObject_InitVar((PyVarObject*)op, &PyBytes_Type, size);

op->ob_shash = -1;

if (!use_calloc) {

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

}

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 = CHARACTER(*str & 255);

return Py_NewRef(op);

}

if (size == 0) {

return bytes_new_empty();

}

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

if (op == NULL)

return NULL;

if (str == NULL)

return (PyObject *) op;

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

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

return bytes_new_empty();

}

else if (size == 1) {

op = CHARACTER(*str & 255);

return Py_NewRef(op);

}

/* Inline PyObject_NewVar */

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

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_InitVar((PyVarObject*)op, &PyBytes_Type, size);

op->ob_shash = -1;

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

return (PyObject *) op;

}

PyObject *

PyBytes_FromFormatV(const char *format, va_list vargs)

{

char *s;

const char *f;

const char *p;

Py_ssize_t prec;

int longflag;

int size_tflag;

/* Longest 64-bit formatted numbers:

char buffer[21];

_PyBytesWriter writer;

_PyBytesWriter_Init(&writer);

s = _PyBytesWriter_Alloc(&writer, strlen(format));

if (s == NULL)

return NULL;

writer.overallocate = 1;

#define WRITE_BYTES(str) \

do { \

s = _PyBytesWriter_WriteBytes(&writer, s, (str), strlen(str)); \

if (s == NULL) \

goto error; \

} while (0)

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

if (*f != '%') {

*s++ = *f;

continue;

}

p = f++;

/* ignore the width (ex: 10 in "%10s") */

while (Py_ISDIGIT(*f))

f++;

/* parse the precision (ex: 10 in "%.10s") */

prec = 0;

if (*f == '.') {

f++;

for (; Py_ISDIGIT(*f); f++) {

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

}

}

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

f++;

/* handle the long flag ('l'), but only for %ld and %lu.

longflag = 0;

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

longflag = 1;

++f;

}

/* handle the size_t flag ('z'). */

size_tflag = 0;

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

size_tflag = 1;

++f;

}

/* subtract bytes preallocated for the format string

writer.min_size -= (f - p + 1);

switch (*f) {

case 'c':

{

int c = va_arg(vargs, int);

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

PyErr_SetString(PyExc_OverflowError,

"PyBytes_FromFormatV(): %c format "

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

goto error;

}

writer.min_size++;

*s++ = (unsigned char)c;

break;

}

case 'd':

if (longflag) {

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

}

else if (size_tflag) {

sprintf(buffer, "%zd", va_arg(vargs, Py_ssize_t));

}

else {

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

}

assert(strlen(buffer) < sizeof(buffer));

WRITE_BYTES(buffer);

break;

case 'u':

if (longflag) {

sprintf(buffer, "%lu", va_arg(vargs, unsigned long));

}

else if (size_tflag) {

sprintf(buffer, "%zu", va_arg(vargs, size_t));

}

else {

sprintf(buffer, "%u", va_arg(vargs, unsigned int));

}

assert(strlen(buffer) < sizeof(buffer));

WRITE_BYTES(buffer);

break;

case 'i':

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

assert(strlen(buffer) < sizeof(buffer));

WRITE_BYTES(buffer);

break;

case 'x':

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

assert(strlen(buffer) < sizeof(buffer));

WRITE_BYTES(buffer);

break;

case 's':

{

Py_ssize_t i;

p = va_arg(vargs, const char*);

if (prec <= 0) {

i = strlen(p);

}

else {

i = 0;

while (i < prec && p[i]) {

i++;

}

}

s = _PyBytesWriter_WriteBytes(&writer, s, p, i);

if (s == NULL)

goto error;

break;

}

case 'p':

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

assert(strlen(buffer) < sizeof(buffer));

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

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

buffer[1] = 'x';

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

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

buffer[0] = '0';

buffer[1] = 'x';

}

WRITE_BYTES(buffer);

break;

case '%':

writer.min_size++;

*s++ = '%';

break;

default:

if (*f == 0) {

/* fix min_size if we reached the end of the format string */

writer.min_size++;

}

/* invalid format string: copy unformatted string and exit */

WRITE_BYTES(p);

return _PyBytesWriter_Finish(&writer, s);

}

}

#undef WRITE_BYTES

return _PyBytesWriter_Finish(&writer, s);

error:

_PyBytesWriter_Dealloc(&writer);

return NULL;

}

PyObject *

PyBytes_FromFormat(const char *format, ...)

{

PyObject* ret;

va_list vargs;

va_start(vargs, format);

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;

}

static char*

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

PyObject **p_result, _PyBytesWriter *writer, char *str)

{

char *p;

PyObject *result;

double x;

size_t len;

int dtoa_flags = 0;

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;

if (flags & F_ALT) {

dtoa_flags |= Py_DTSF_ALT;

}

p = PyOS_double_to_string(x, type, prec, dtoa_flags, NULL);

if (p == NULL)

return NULL;

len = strlen(p);

if (writer != NULL) {

str = _PyBytesWriter_Prepare(writer, str, len);

if (str == NULL) {

PyMem_Free(p);

return NULL;

}

memcpy(str, p, len);

PyMem_Free(p);

str += len;

return str;

}

result = PyBytes_FromStringAndSize(p, len);

PyMem_Free(p);

*p_result = result;

return result != NULL ? str : NULL;

}

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

assert(PyLong_Check(iobj));

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

Py_DECREF(iobj);

return result;

}

if (!PyErr_ExceptionMatches(PyExc_TypeError))

return NULL;

}

PyErr_Format(PyExc_TypeError,

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

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

: "a real number",

Py_TYPE(v)->tp_name);

return NULL;

}

static int

byte_converter(PyObject *arg, char *p)

{

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

*p = PyBytes_AS_STRING(arg)[0];

return 1;

}

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

*p = PyByteArray_AS_STRING(arg)[0];

return 1;

}

else {

int overflow;

long ival = PyLong_AsLongAndOverflow(arg, &overflow);

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

if (PyErr_ExceptionMatches(PyExc_TypeError)) {

goto onError;

}

return 0;

}

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

/* this includes an overflow in converting to C long */

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 *_PyBytes_FromBuffer(PyObject *x);

static PyObject *

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

{

PyObject *func, *result;

/* is it a bytes object? */

if (PyBytes_Check(v)) {

*pbuf = PyBytes_AS_STRING(v);

*plen = PyBytes_GET_SIZE(v);

return Py_NewRef(v);

}

if (PyByteArray_Check(v)) {

*pbuf = PyByteArray_AS_STRING(v);

*plen = PyByteArray_GET_SIZE(v);

return Py_NewRef(v);

}

/* does it support __bytes__? */

func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));

if (func != NULL) {

result = _PyObject_CallNoArgs(func);

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;

}

/* does it support buffer protocol? */

if (PyObject_CheckBuffer(v)) {

/* maybe we can avoid making a copy of the buffer object here? */

result = _PyBytes_FromBuffer(v);

if (result == NULL)

return NULL;

*pbuf = PyBytes_AS_STRING(result);

*plen = PyBytes_GET_SIZE(result);

return result;

}

PyErr_Format(PyExc_TypeError,

"%%b requires a bytes-like object, "

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

Py_TYPE(v)->tp_name);

return NULL;

}

PyObject *

_PyBytes_FormatEx(const char *format, Py_ssize_t format_len,

PyObject *args, int use_bytearray)

{

const char *fmt;

char *res;

Py_ssize_t arglen, argidx;

Py_ssize_t fmtcnt;

int args_owned = 0;

PyObject *dict = NULL;

_PyBytesWriter writer;

if (args == NULL) {

PyErr_BadInternalCall();

return NULL;

}

fmt = format;

fmtcnt = format_len;

_PyBytesWriter_Init(&writer);

writer.use_bytearray = use_bytearray;

res = _PyBytesWriter_Alloc(&writer, fmtcnt);

if (res == NULL)

return NULL;

if (!use_bytearray)

writer.overallocate = 1;

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 != '%') {

Py_ssize_t len;

char *pos;

pos = (char *)memchr(fmt + 1, '%', fmtcnt);

if (pos != NULL)

len = pos - fmt;

else

len = fmtcnt + 1;

assert(len != 0);

memcpy(res, fmt, len);

res += len;

fmt += len;

fmtcnt -= (len - 1);

}

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

Py_ssize_t alloc;

fmt++;

if (*fmt == '%') {

*res++ = '%';

fmt++;

fmtcnt--;

continue;

}

if (*fmt == '(') {

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

}

/* Parse flags. Example: "%+i" => flags=F_SIGN. */

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;

}

/* Parse width. Example: "%10s" => width=10 */

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

}

}

/* Parse precision. Example: "%.3f" => prec=3 */

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;

}

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

if (v == NULL)

goto error;

if (fmtcnt == 0) {

/* last write: disable writer overallocation */

writer.overallocate = 0;

}

sign = 0;

fill = ' ';

switch (c) {

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

if (PyLong_CheckExact(v)

&& width == -1 && prec == -1

&& !(flags & (F_SIGN | F_BLANK))

&& c != 'X')

{

/* Fast path */

int alternate = flags & F_ALT;

int base;

switch(c)

{

default:

Py_UNREACHABLE();

case 'd':

case 'i':

case 'u':

base = 10;

break;

case 'o':

base = 8;

break;

case 'x':

case 'X':

base = 16;

break;

}

/* Fast path */

writer.min_size -= 2; /* size preallocated for "%d" */

res = _PyLong_FormatBytesWriter(&writer, res,

v, base, alternate);

if (res == NULL)

goto error;

continue;

}

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

if (width == -1 && prec == -1

&& !(flags & (F_SIGN | F_BLANK)))

{

/* Fast path */

writer.min_size -= 2; /* size preallocated for "%f" */

res = formatfloat(v, flags, prec, c, NULL, &writer, res);

if (res == NULL)

goto error;

continue;

}

if (!formatfloat(v, flags, prec, c, &temp, NULL, res))

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;

if (width == -1) {

/* Fast path */

*res++ = onechar;

continue;

}

break;

default:

PyErr_Format(PyExc_ValueError,

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

"at index %zd",

c, c,

(Py_ssize_t)(fmt - 1 - 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;

alloc = width;

if (sign != 0 && len == width)

alloc++;

/* 2: size preallocated for %s */

if (alloc > 2) {

res = _PyBytesWriter_Prepare(&writer, res, alloc - 2);

if (res == NULL)

goto error;

}

#ifndef NDEBUG

char *before = res;

/* Write the sign if needed */

if (sign) {

if (fill != ' ')

*res++ = sign;

if (width > len)

width--;

}

/* Write the numeric prefix for "x", "X" and "o" formats

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

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

assert(pbuf[1] == c);

if (fill != ' ') {

*res++ = *pbuf++;

*res++ = *pbuf++;

}

width -= 2;

if (width < 0)

width = 0;

len -= 2;

}

/* Pad left with the fill character if needed */

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

memset(res, fill, width - len);

res += (width - len);

width = len;

}

/* If padding with spaces: write sign if needed and/or numeric

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

}

}

/* Copy bytes */