#include "Python.h"

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

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

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

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

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

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION_SEQUENCE_FAST()

#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_list.h" // _PyList_GetItemRef

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

#include "clinic/bytesobject.c.h"

#define PyBytesObject_SIZE _PyBytesObject_SIZE

static void* _PyBytesWriter_ResizeAndUpdatePointer(PyBytesWriter *writer,

Py_ssize_t size, void *data);

static Py_ssize_t _PyBytesWriter_ResizeToAllocated(PyBytesWriter *writer);

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

{

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

assert(_Py_IsImmortal(empty));

return empty;

}

static inline PyObject*

bytes_get_char(uint8_t ch)

{

PyObject *obj = (PyObject*)CHARACTER(ch);

assert(_Py_IsImmortal(obj));

return obj;

}

static inline void

set_ob_shash(PyBytesObject *a, Py_hash_t hash)

{

#ifdef Py_GIL_DISABLED

_Py_atomic_store_ssize_relaxed(&a->ob_shash, hash);

a->ob_shash = hash;

}

#define get_ob_shash(op) _PyBytes_GET_CACHED_HASH(op)

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

return bytes_get_char((uint8_t)*str);

}

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

return bytes_get_char((uint8_t)*str);

}

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

{

/* Longest 64-bit formatted numbers:

char buffer[21];

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

#define WRITE_BYTES(str, len_expr) \

do { \

size_t _len = (len_expr); \

size_t _prealloc = (f - p + 1); \

if (_len > _prealloc) { \

s = PyBytesWriter_GrowAndUpdatePointer(writer, _len - _prealloc, s); \

if (s == NULL) { \

return NULL; \

} \

} \

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

s += _len; \

} while (0)

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

if (*f != '%') {

*s++ = *f;

continue;

}

const char *p = f++;

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

while (Py_ISDIGIT(*f))

f++;

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

Py_ssize_t prec = 0;

if (*f == '.') {

f++;

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

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

}

}

assert(prec >= 0);

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

f++;

}

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

int longflag = 0;

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

longflag = 1;

++f;

}

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

int size_tflag = 0;

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

size_tflag = 1;

++f;

}

Py_ssize_t len;

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

return NULL;

}

*s++ = (unsigned char)c;

break;

}

case 'd':

if (longflag) {

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

}

else if (size_tflag) {

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

}

else {

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

}

assert(1 <= len && len < (Py_ssize_t)sizeof(buffer));

WRITE_BYTES(buffer, len);

break;

case 'u':

if (longflag) {

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

}

else if (size_tflag) {

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

}

else {

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

}

assert(1 <= len && len < (Py_ssize_t)sizeof(buffer));

WRITE_BYTES(buffer, len);

break;

case 'i':

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

assert(1 <= len && len < (Py_ssize_t)sizeof(buffer));

WRITE_BYTES(buffer, len);

break;

case 'x':

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

assert(1 <= len && len < (Py_ssize_t)sizeof(buffer));

WRITE_BYTES(buffer, len);

break;

case 's':

{

const char *str = va_arg(vargs, const char*);

if (prec == 0) {

len = strlen(str);

}

else {

const char *end = memchr(str, 0, prec);

if (end != NULL) {

len = (end - str);

}

else {

len = (size_t)prec;

}

}

WRITE_BYTES(str, len);

break;

}

case 'p':

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

assert(1 <= len && len < (Py_ssize_t)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, len + 1);

buffer[0] = '0';

buffer[1] = 'x';

len += 2;

}

WRITE_BYTES(buffer, len);

break;

case '%':

*s++ = '%';

break;

default:

// Invalid format string: copy unformatted string and exit.

// No need to grow the writer buffer, we already preallocated

// enough bytes.

len = strlen(p);

memcpy(s, p, len);

s += len;

return s;

}

}

return s;

#undef WRITE_BYTES

}

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;

}

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

}

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;

}

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;