/* bytes object implementation */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

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

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

#include "pycore_bytesobject.h" // struct _Py_bytes_state

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

#include "pycore_format.h" // F_LJUST

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

/*[clinic input]

class bytes "PyBytesObject *" "&PyBytes_Type"

[clinic start generated code]*/

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

#include "clinic/bytesobject.c.h"

_Py_IDENTIFIER(__bytes__);

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

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

Using PyBytesObject_SIZE instead of sizeof(PyBytesObject) saves

3 or 7 bytes per bytes object allocation on a typical system.

*/

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

/* Forward declaration */

Py_LOCAL_INLINE(Py_ssize_t) _PyBytesWriter_GetSize(_PyBytesWriter *writer,

char *str);

static struct _Py_bytes_state*

get_bytes_state(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->bytes;

}

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

static inline PyObject* bytes_get_empty(void)

{

struct _Py_bytes_state *state = get_bytes_state();

// bytes_get_empty() must not be called before _PyBytes_Init()

// or after _PyBytes_Fini()

assert(state->empty_string != NULL);

return state->empty_string;

}

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

static inline PyObject* bytes_new_empty(void)

{

PyObject *empty = bytes_get_empty();

Py_INCREF(empty);

return (PyObject *)empty;

}

static int

bytes_create_empty_string_singleton(struct _Py_bytes_state *state)

{

// Create the empty bytes string singleton

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

if (op == NULL) {

return -1;

}

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

op->ob_shash = -1;

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

assert(state->empty_string == NULL);

state->empty_string = (PyObject *)op;

return 0;

}

/*

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

struct _Py_bytes_state *state = get_bytes_state();

op = state->characters[*str & UCHAR_MAX];

if (op != NULL) {

Py_INCREF(op);

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

/* share short strings */

if (size == 1) {

struct _Py_bytes_state *state = get_bytes_state();

Py_INCREF(op);

state->characters[*str & UCHAR_MAX] = 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;

}

struct _Py_bytes_state *state = get_bytes_state();

if (size == 0) {

return bytes_new_empty();

}

else if (size == 1) {

op = state->characters[*str & UCHAR_MAX];

if (op != NULL) {

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

op->ob_shash = -1;

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

/* share short strings */

if (size == 1) {

assert(state->characters[*str & UCHAR_MAX] == NULL);

Py_INCREF(op);

state->characters[*str & UCHAR_MAX] = op;

}

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:

- "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];

_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.

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;

}

/* subtract bytes preallocated for the format string

(ex: 2 for "%s") */

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;

#ifdef HAVE_STDARG_PROTOTYPES

va_start(vargs, format);

#else

va_start(vargs);

#endif

ret = PyBytes_FromFormatV(format, vargs);

va_end(vargs);

return ret;

}

/* Helpers for formatstring */

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;

}

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

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;

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;

len = strlen(p);

if (writer != NULL) {

str = _PyBytesWriter_Prepare(writer, str, len);

if (str == NULL)

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

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

}

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

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;

#endif

/* Write the sign if needed */