/* bytes object implementation */

#include "Python.h"

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

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

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

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

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_format.h" // F_LJUST

#include "pycore_freelist.h" // _Py_FREELIST_FREE()

#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 "pycore_unicodeobject.h" // _PyUnicode_FormatLong()

#include <stddef.h>

/*[clinic input]

class bytes "PyBytesObject *" "&PyBytes_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=7a238f965d64892b]*/

#include "clinic/bytesobject.c.h"

#define PyBytesObject_SIZE _PyBytesObject_SIZE

/* Forward declaration */

static void* _PyBytesWriter_ResizeAndUpdatePointer(PyBytesWriter *writer,

Py_ssize_t size, void *data);

static Py_ssize_t _PyBytesWriter_GetAllocated(PyBytesWriter *writer);

#define CHARACTERS _Py_SINGLETON(bytes_characters)

#define CHARACTER(ch) \

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

#define EMPTY (&_Py_SINGLETON(bytes_empty))

// Return a reference to the immortal empty bytes string singleton.

static inline PyObject* bytes_get_empty(void)

{

PyObject *empty = &EMPTY->ob_base.ob_base;

assert(_Py_IsImmortal(empty));

return empty;

}

static inline void

set_ob_shash(PyBytesObject *a, Py_hash_t hash)

{

_Py_COMP_DIAG_PUSH

_Py_COMP_DIAG_IGNORE_DEPR_DECLS

#ifdef Py_GIL_DISABLED

_Py_atomic_store_ssize_relaxed(&a->ob_shash, hash);

#else

a->ob_shash = hash;

#endif

_Py_COMP_DIAG_POP

}

static inline Py_hash_t

get_ob_shash(PyBytesObject *a)

{

_Py_COMP_DIAG_PUSH

_Py_COMP_DIAG_IGNORE_DEPR_DECLS

#ifdef Py_GIL_DISABLED

return _Py_atomic_load_ssize_relaxed(&a->ob_shash);

#else

return a->ob_shash;

#endif

_Py_COMP_DIAG_POP

}

/*

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

string containing exactly 'size' bytes.

For PyBytes_FromStringAndSize(), 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) {

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

set_ob_shash(op, -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);

assert(_Py_IsImmortal(op));

return (PyObject *)op;

}

if (size == 0) {

return bytes_get_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_get_empty();

}

else if (size == 1) {

op = CHARACTER(*str & 255);

assert(_Py_IsImmortal(op));

return (PyObject *)op;

}

/* Inline PyObject_NewVar */

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

if (op == NULL) {

return PyErr_NoMemory();

}

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

set_ob_shash(op, -1);

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

return (PyObject *) op;

}

static char*

bytes_fromformat(PyBytesWriter *writer, Py_ssize_t writer_pos,

const char *format, va_list vargs)

{

const char *f;

const char *p;

Py_ssize_t prec;

int longflag;

int size_tflag;

/* Longest 64-bit formatted numbers:

- "18446744073709551615\0" (21 bytes)

- "-9223372036854775808\0" (21 bytes)

Decimal takes the most space (it isn't enough for octal.)

Longest 64-bit pointer representation:

"0xffffffffffffffff\0" (19 bytes). */

char buffer[21];

char *s = (char*)PyBytesWriter_GetData(writer) + writer_pos;

#define WRITE_BYTES_LEN(str, len_expr) \

do { \

size_t len = (len_expr); \

s = PyBytesWriter_GrowAndUpdatePointer(writer, len, s); \

if (s == NULL) { \

goto error; \

} \

memcpy(s, (str), len); \

s += len; \

} while (0)

#define WRITE_BYTES(str) WRITE_BYTES_LEN(str, strlen(str))

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.

others can be added when necessary. */

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;

}

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;

}

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

}

}

WRITE_BYTES_LEN(p, i);

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

*s++ = '%';

break;

default:

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

WRITE_BYTES(p);

return s;

}

}

#undef WRITE_BYTES

#undef WRITE_BYTES_LEN

return s;

error:

return NULL;

}

PyObject *

PyBytes_FromFormatV(const char *format, va_list vargs)

{

Py_ssize_t alloc = strlen(format);

PyBytesWriter *writer = PyBytesWriter_Create(alloc);

if (writer == NULL) {

return NULL;

}

char *s = bytes_fromformat(writer, 0, format, vargs);

if (s == NULL) {

PyBytesWriter_Discard(writer);

return NULL;

}

return PyBytesWriter_FinishWithPointer(writer, s);

}

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;

}

/* Helpers for formatstring */

#define FORMAT_ERROR(EXC, FMT, ...) do { \

if (key != NULL) { \

PyErr_Format((EXC), "format argument %R: " FMT, \

key, __VA_ARGS__); \

} \

else if (argidx >= 0) { \

PyErr_Format((EXC), "format argument %zd: " FMT, \

argidx, __VA_ARGS__); \

} \

else { \

PyErr_Format((EXC), "format argument: " FMT, __VA_ARGS__); \

} \

} while (0)

Py_LOCAL_INLINE(PyObject *)

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

{

Py_ssize_t argidx = *p_argidx;

if (argidx < arglen) {

(*p_argidx)++;

if (arglen >= 0) {

return PyTuple_GetItem(args, argidx);

}

else if (allowone) {

return args;

}

}

PyErr_Format(PyExc_TypeError,

"not enough arguments for format string (got %zd)",

arglen < 0 ? 1 : arglen);

return NULL;

}

/* Returns a new reference to a PyBytes object, or NULL on failure. */

static char*

formatfloat(PyObject *v, Py_ssize_t argidx, PyObject *key,

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

if (PyErr_ExceptionMatches(PyExc_TypeError)) {

FORMAT_ERROR(PyExc_TypeError,

"%%%c requires a real number, not %T",

type, v);

}

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_GrowAndUpdatePointer(writer, len, str);

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, Py_ssize_t argidx, PyObject *key,

int flags, int prec, int type)

{

PyObject *result, *iobj;

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;

}

FORMAT_ERROR(PyExc_TypeError,

"%%%c requires %s, not %T",

type,

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

: "a real number",

v);

return NULL;

}

static int

byte_converter(PyObject *arg, Py_ssize_t argidx, PyObject *key, char *p)

{

if (PyBytes_Check(arg)) {

if (PyBytes_GET_SIZE(arg) != 1) {

FORMAT_ERROR(PyExc_TypeError,

"%%c requires an integer in range(256) or "

"a single byte, not a bytes object of length %zd",

PyBytes_GET_SIZE(arg));

return 0;

}

*p = PyBytes_AS_STRING(arg)[0];

return 1;

}

else if (PyByteArray_Check(arg)) {

if (PyByteArray_GET_SIZE(arg) != 1) {

FORMAT_ERROR(PyExc_TypeError,

"%%c requires an integer in range(256) or "

"a single byte, not a bytearray object of length %zd",

PyByteArray_GET_SIZE(arg));

return 0;

}

*p = PyByteArray_AS_STRING(arg)[0];

return 1;

}

else if (PyIndex_Check(arg)) {

int overflow;

long ival = PyLong_AsLongAndOverflow(arg, &overflow);

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

return 0;

}

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

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

FORMAT_ERROR(PyExc_OverflowError,

"%%c argument not in range(256)%s", "");

return 0;

}

*p = (char)ival;

return 1;

}

FORMAT_ERROR(PyExc_TypeError,

"%%c requires an integer in range(256) or "

"a single byte, not %T",

arg);

return 0;

}

static PyObject *_PyBytes_FromBuffer(PyObject *x);

static PyObject *

format_obj(PyObject *v, Py_ssize_t argidx, PyObject *key,

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,

"%T.__bytes__() must return a bytes, not %T",

v, result);

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;

}

FORMAT_ERROR(PyExc_TypeError,

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

"or an object that implements __bytes__, not %T",

v);

return NULL;

}

/* fmt%(v1,v2,...) is roughly equivalent to sprintf(fmt, v1, v2, ...) */

PyObject *

_PyBytes_FormatEx(const char *format, Py_ssize_t format_len,

PyObject *args, int use_bytearray)

{

const char *fmt;

Py_ssize_t arglen, argidx;

Py_ssize_t fmtcnt;

int args_owned = 0;

PyObject *dict = NULL;

PyObject *key = NULL;

if (args == NULL) {

PyErr_BadInternalCall();

return NULL;

}

fmt = format;

fmtcnt = format_len;

PyBytesWriter *writer;

if (use_bytearray) {

writer = _PyBytesWriter_CreateByteArray(fmtcnt);

}

else {

writer = PyBytesWriter_Create(fmtcnt);

}

if (writer == NULL) {

return NULL;

}

char *res = PyBytesWriter_GetData(writer);

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;

}

Py_CLEAR(key);

const char *fmtstart = fmt;

if (*fmt == '(') {

const char *keystart;

Py_ssize_t keylen;

int pcount = 1;

if (dict == NULL) {

PyErr_Format(PyExc_TypeError,

"format requires a mapping, not %T",

args);

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_Format(PyExc_ValueError,

"stray %% or incomplete format key "

"at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

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

if (args == NULL) {

goto error;

}

args_owned = 1;

arglen = -3;

argidx = -4;

}

else {

if (arglen < -1) {

PyErr_Format(PyExc_ValueError,

"format requires a parenthesised mapping key "

"at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

goto error;

}

}

/* 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 == '*') {

if (arglen < -1) {

PyErr_Format(PyExc_ValueError,

"* cannot be used with a parenthesised mapping key "

"at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

goto error;

}

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

if (v == NULL)

goto error;

if (!PyLong_Check(v)) {

FORMAT_ERROR(PyExc_TypeError, "* requires int, not %T", v);

goto error;

}

width = PyLong_AsSsize_t(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

FORMAT_ERROR(PyExc_OverflowError,

"too big for width%s", "");

}

goto error;

}

if (width < 0) {

flags |= F_LJUST;

width = -width;

}

if (--fmtcnt >= 0)

c = *fmt++;

}

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

width = c - '0';

while (--fmtcnt >= 0) {

c = Py_CHARMASK(*fmt++);

if (!Py_ISDIGIT(c))

break;

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

PyErr_Format(PyExc_ValueError,

"width too big at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

goto error;

}

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

}

}

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

if (c == '.') {

prec = 0;

if (--fmtcnt >= 0)

c = *fmt++;

if (c == '*') {

if (arglen < -1) {

PyErr_Format(PyExc_ValueError,

"* cannot be used with a parenthesised mapping key "

"at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

goto error;

}

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

if (v == NULL)

goto error;

if (!PyLong_Check(v)) {

FORMAT_ERROR(PyExc_TypeError,

"* requires int, not %T", v);

goto error;

}

prec = PyLong_AsInt(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

FORMAT_ERROR(PyExc_OverflowError,

"too big for precision%s", "");

}

goto error;

}

if (prec < 0)

prec = 0;

if (--fmtcnt >= 0)

c = *fmt++;

}

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

prec = c - '0';

while (--fmtcnt >= 0) {

c = Py_CHARMASK(*fmt++);

if (!Py_ISDIGIT(c))

break;

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

PyErr_Format(PyExc_ValueError,

"precision too big at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

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_Format(PyExc_ValueError,

"stray %% at position %zd",

(Py_ssize_t)(fmtstart - format - 1));

goto error;

}

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

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, argidx, key, &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 */

res = _PyLong_FormatBytesWriter(writer, res,

v, base, alternate);

if (res == NULL)

goto error;

continue;

}

temp = formatlong(v, argidx, key, 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 */

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

if (res == NULL)

goto error;

continue;

}

if (!formatfloat(v, argidx, key, 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':