#include "Python.h"

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

#include "pycore_fileutils.h" // _Py_BEGIN_SUPPRESS_IPH

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

#include "pycore_frame.h" // PyFrameObject

#include "pycore_interp.h" // PyInterpreterState.gc

#include "pycore_interpframe.h" // _PyFrame_GetCode()

#include "pycore_pyerrors.h" // _PyErr_GetRaisedException()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_traceback.h" // EXCEPTION_TB_HEADER

#include "frameobject.h" // PyFrame_New()

#include "../Parser/tokenizer/tokenizer.h"

#include "osdefs.h" // SEP

#ifdef HAVE_UNISTD_H

# include <unistd.h> // lseek()

#if (defined(HAVE_EXECINFO_H) && defined(HAVE_DLFCN_H) && defined(HAVE_LINK_H))

# define _PY_HAS_BACKTRACE_HEADERS 1

#if (defined(__APPLE__) && defined(HAVE_EXECINFO_H) && defined(HAVE_DLFCN_H))

# define _PY_HAS_BACKTRACE_HEADERS 1

#ifdef _PY_HAS_BACKTRACE_HEADERS

# include <execinfo.h> // backtrace(), backtrace_symbols()

# include <dlfcn.h> // dladdr1()

#ifdef HAVE_LINK_H

# include <link.h> // struct DL_info

# if defined(__APPLE__) && defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR)

# define CAN_C_BACKTRACE

# elif defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR1)

# define CAN_C_BACKTRACE

#if defined(__STDC_NO_VLA__) && (__STDC_NO_VLA__ == 1)

# define VLA(type, name, size) type *name = alloca(sizeof(type) * (size))

#elif !defined(__STDC_NO_VLA__) || (__STDC_NO_VLA__ == 0)

# define VLA(type, name, size) type name[size]

#elif defined(CAN_C_BACKTRACE)

# undef CAN_C_BACKTRACE

#define OFF(x) offsetof(PyTracebackObject, x)

#define PUTS(fd, str) (void)_Py_write_noraise(fd, str, strlen(str))

#define MAX_STRING_LENGTH 500

#define MAX_FRAME_DEPTH 100

#define DEFAULT_MAX_NTHREADS 100

#define _PyTracebackObject_CAST(op) ((PyTracebackObject *)(op))

#include "clinic/traceback.c.h"

#ifdef MS_WINDOWS

typedef HRESULT (WINAPI *PF_GET_THREAD_DESCRIPTION)(HANDLE, PWSTR*);

static PF_GET_THREAD_DESCRIPTION pGetThreadDescription = NULL;

static PyObject *

tb_create_raw(PyTracebackObject *next, PyFrameObject *frame, int lasti,

int lineno)

{

PyTracebackObject *tb;

assert(next == NULL || PyTraceBack_Check(next));

assert(frame != NULL);

assert(PyFrame_Check(frame));

tb = _Py_FREELIST_POP(PyTracebackObject, tracebacks);

if (tb == NULL) {

tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);

}

if (tb != NULL) {

tb->tb_next = (PyTracebackObject*)Py_XNewRef(next);

tb->tb_frame = (PyFrameObject*)Py_NewRef(frame);

tb->tb_lasti = lasti;

tb->tb_lineno = lineno;

PyObject_GC_Track(tb);

}

return (PyObject *)tb;

}

static PyObject *

tb_new_impl(PyTypeObject *type, PyObject *tb_next, PyFrameObject *tb_frame,

int tb_lasti, int tb_lineno)

{

if (tb_next == Py_None) {

tb_next = NULL;

} else if (!PyTraceBack_Check(tb_next)) {

return PyErr_Format(PyExc_TypeError,

"expected traceback object or None, got '%s'",

Py_TYPE(tb_next)->tp_name);

}

return tb_create_raw((PyTracebackObject *)tb_next, tb_frame, tb_lasti,

tb_lineno);

}

static PyObject *

tb_dir(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))

{

return Py_BuildValue("[ssss]", "tb_frame", "tb_next",

"tb_lasti", "tb_lineno");

}

static PyObject *

traceback_tb_next_get_impl(PyTracebackObject *self)

{

PyObject* ret = (PyObject*)self->tb_next;

if (!ret) {

ret = Py_None;

}

return Py_NewRef(ret);

}

static int

tb_get_lineno(PyObject *op)

{

PyTracebackObject *tb = _PyTracebackObject_CAST(op);

_PyInterpreterFrame* frame = tb->tb_frame->f_frame;

assert(frame != NULL);

return PyCode_Addr2Line(_PyFrame_GetCode(frame), tb->tb_lasti);

}

static PyObject *

tb_lineno_get(PyObject *op, void *Py_UNUSED(_))

{

PyTracebackObject *self = _PyTracebackObject_CAST(op);

int lineno = self->tb_lineno;

if (lineno == -1) {

lineno = tb_get_lineno(op);

if (lineno < 0) {

Py_RETURN_NONE;

}

}

return PyLong_FromLong(lineno);

}

static int

traceback_tb_next_set_impl(PyTracebackObject *self, PyObject *value)

{

/* We accept None or a traceback object, and map None -> NULL (inverse of

if (value == Py_None) {

value = NULL;

} else if (!PyTraceBack_Check(value)) {

PyErr_Format(PyExc_TypeError,

"expected traceback object, got '%s'",

Py_TYPE(value)->tp_name);

return -1;

}

/* Check for loops */

PyTracebackObject *cursor = (PyTracebackObject *)value;

Py_XINCREF(cursor);

while (cursor) {

if (cursor == self) {

PyErr_Format(PyExc_ValueError, "traceback loop detected");

Py_DECREF(cursor);

return -1;

}

Py_BEGIN_CRITICAL_SECTION(cursor);

Py_XINCREF(cursor->tb_next);

Py_SETREF(cursor, cursor->tb_next);

Py_END_CRITICAL_SECTION();

}

Py_XSETREF(self->tb_next, (PyTracebackObject *)Py_XNewRef(value));

return 0;

}

static PyMethodDef tb_methods[] = {

{"__dir__", tb_dir, METH_NOARGS, NULL},

{NULL, NULL, 0, NULL},

};

static PyMemberDef tb_memberlist[] = {

{"tb_frame", _Py_T_OBJECT, OFF(tb_frame), Py_READONLY|Py_AUDIT_READ},

{"tb_lasti", Py_T_INT, OFF(tb_lasti), Py_READONLY},

{NULL} /* Sentinel */

};

static PyGetSetDef tb_getsetters[] = {

TRACEBACK_TB_NEXT_GETSETDEF

{"tb_lineno", tb_lineno_get, NULL, NULL, NULL},

{NULL} /* Sentinel */

};

static void

tb_dealloc(PyObject *op)

{

PyTracebackObject *tb = _PyTracebackObject_CAST(op);

PyObject_GC_UnTrack(tb);

Py_XDECREF(tb->tb_next);

Py_XDECREF(tb->tb_frame);

_Py_FREELIST_FREE(tracebacks, tb, PyObject_GC_Del);

}

static int

tb_traverse(PyObject *op, visitproc visit, void *arg)

{

PyTracebackObject *tb = _PyTracebackObject_CAST(op);

Py_VISIT(tb->tb_next);

Py_VISIT(tb->tb_frame);

return 0;

}

static int

tb_clear(PyObject *op)

{

PyTracebackObject *tb = _PyTracebackObject_CAST(op);

Py_CLEAR(tb->tb_next);

Py_CLEAR(tb->tb_frame);

return 0;

}

PyTypeObject PyTraceBack_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"traceback",

sizeof(PyTracebackObject),

0,

tb_dealloc, /*tp_dealloc*/

0, /*tp_vectorcall_offset*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_as_async*/

0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */

tb_new__doc__, /* tp_doc */

tb_traverse, /* tp_traverse */

tb_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

tb_methods, /* tp_methods */

tb_memberlist, /* tp_members */

tb_getsetters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

tb_new, /* tp_new */

};

_PyTraceBack_FromFrame(PyObject *tb_next, PyFrameObject *frame)

{

assert(tb_next == NULL || PyTraceBack_Check(tb_next));

assert(frame != NULL);

int addr = _PyInterpreterFrame_LASTI(frame->f_frame) * sizeof(_Py_CODEUNIT);

return tb_create_raw((PyTracebackObject *)tb_next, frame, addr, -1);

}

PyTraceBack_Here(PyFrameObject *frame)

{

PyObject *exc = PyErr_GetRaisedException();

assert(PyExceptionInstance_Check(exc));

PyObject *tb = PyException_GetTraceback(exc);

PyObject *newtb = _PyTraceBack_FromFrame(tb, frame);

Py_XDECREF(tb);

if (newtb == NULL) {

_PyErr_ChainExceptions1(exc);

return -1;

}

PyException_SetTraceback(exc, newtb);

Py_XDECREF(newtb);

PyErr_SetRaisedException(exc);

return 0;

}

void _PyTraceback_Add(const char *funcname, const char *filename, int lineno)

{

PyObject *globals;

PyCodeObject *code;

PyFrameObject *frame;

PyThreadState *tstate = _PyThreadState_GET();

/* Save and clear the current exception. Python functions must not be

PyObject *exc = _PyErr_GetRaisedException(tstate);

globals = PyDict_New();

if (!globals)

goto error;

code = PyCode_NewEmpty(filename, funcname, lineno);

if (!code) {

Py_DECREF(globals);

goto error;

}

frame = PyFrame_New(tstate, code, globals, NULL);

Py_DECREF(globals);

Py_DECREF(code);

if (!frame)

goto error;

frame->f_lineno = lineno;

_PyErr_SetRaisedException(tstate, exc);

PyTraceBack_Here(frame);

Py_DECREF(frame);

return;

error:

_PyErr_ChainExceptions1(exc);

}

static PyObject *

_Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject *io)

{

Py_ssize_t i;

PyObject *binary;

PyObject *v;

Py_ssize_t npath;

size_t taillen;

PyObject *syspath;

PyObject *path;

const char* tail;

PyObject *filebytes;

const char* filepath;

Py_ssize_t len;

PyObject* result;

PyObject *open = NULL;

filebytes = PyUnicode_EncodeFSDefault(filename);

if (filebytes == NULL) {

PyErr_Clear();

return NULL;

}

filepath = PyBytes_AS_STRING(filebytes);

/* Search tail of filename in sys.path before giving up */

tail = strrchr(filepath, SEP);

if (tail == NULL)

tail = filepath;

else

tail++;

taillen = strlen(tail);

if (PySys_GetOptionalAttr(&_Py_ID(path), &syspath) < 0) {

PyErr_Clear();

goto error;

}

if (syspath == NULL || !PyList_Check(syspath)) {

goto error;

}

npath = PyList_Size(syspath);

open = PyObject_GetAttr(io, &_Py_ID(open));

if (open == NULL) {

goto error;

}

for (i = 0; i < npath; i++) {

v = PyList_GetItem(syspath, i);

if (v == NULL) {

PyErr_Clear();

break;

}

if (!PyUnicode_Check(v))

continue;

path = PyUnicode_EncodeFSDefault(v);

if (path == NULL) {

PyErr_Clear();

continue;

}

len = PyBytes_GET_SIZE(path);

if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1) {

Py_DECREF(path);

continue; /* Too long */

}

strcpy(namebuf, PyBytes_AS_STRING(path));

Py_DECREF(path);

if (strlen(namebuf) != (size_t)len)

continue; /* v contains '\0' */

if (len > 0 && namebuf[len-1] != SEP)

namebuf[len++] = SEP;

strcpy(namebuf+len, tail);

binary = PyObject_CallFunction(open, "ss", namebuf, "rb");

if (binary != NULL) {

result = binary;

goto finally;

}

PyErr_Clear();

}

goto error;

error:

result = NULL;

finally:

Py_XDECREF(open);

Py_XDECREF(syspath);

Py_DECREF(filebytes);

return result;

}

_Py_WriteIndent(int indent, PyObject *f)

{

char buf[11] = " ";

assert(strlen(buf) == 10);

while (indent > 0) {

if (indent < 10) {

buf[indent] = '\0';

}

if (PyFile_WriteString(buf, f) < 0) {

return -1;

}

indent -= 10;

}

return 0;

}

static int

display_source_line(PyObject *f, PyObject *filename, int lineno, int indent,

int *truncation, PyObject **line)

{

int fd;

int i;

char *found_encoding;

const char *encoding;

PyObject *io;

PyObject *binary;

PyObject *fob = NULL;

PyObject *lineobj = NULL;

PyObject *res;

char buf[MAXPATHLEN+1];

int kind;

const void *data;

/* open the file */

if (filename == NULL)

return 0;

/* Do not attempt to open things like <string> or <stdin> */

assert(PyUnicode_Check(filename));

if (PyUnicode_READ_CHAR(filename, 0) == '<') {

Py_ssize_t len = PyUnicode_GET_LENGTH(filename);

if (len > 0 && PyUnicode_READ_CHAR(filename, len - 1) == '>') {

return 0;

}

}

io = PyImport_ImportModule("io");

if (io == NULL) {

return -1;

}

binary = _PyObject_CallMethod(io, &_Py_ID(open), "Os", filename, "rb");

if (binary == NULL) {

PyErr_Clear();

binary = _Py_FindSourceFile(filename, buf, sizeof(buf), io);

if (binary == NULL) {

Py_DECREF(io);

return -1;

}

}

/* use the right encoding to decode the file as unicode */

fd = PyObject_AsFileDescriptor(binary);

if (fd < 0) {

Py_DECREF(io);

Py_DECREF(binary);

return 0;

}

found_encoding = _PyTokenizer_FindEncodingFilename(fd, filename);

if (found_encoding == NULL)

PyErr_Clear();

encoding = (found_encoding != NULL) ? found_encoding : "utf-8";

/* Reset position */

if (lseek(fd, 0, SEEK_SET) == (off_t)-1) {

Py_DECREF(io);

Py_DECREF(binary);

PyMem_Free(found_encoding);

return 0;

}

fob = _PyObject_CallMethod(io, &_Py_ID(TextIOWrapper),

"Os", binary, encoding);

Py_DECREF(io);

PyMem_Free(found_encoding);

if (fob == NULL) {

PyErr_Clear();

res = PyObject_CallMethodNoArgs(binary, &_Py_ID(close));

Py_DECREF(binary);

if (res)

Py_DECREF(res);

else

PyErr_Clear();

return 0;

}

Py_DECREF(binary);

/* get the line number lineno */

for (i = 0; i < lineno; i++) {

Py_XDECREF(lineobj);

lineobj = PyFile_GetLine(fob, -1);

if (!lineobj) {

PyErr_Clear();

break;

}

}

res = PyObject_CallMethodNoArgs(fob, &_Py_ID(close));

if (res) {

Py_DECREF(res);

}

else {

PyErr_Clear();

}

Py_DECREF(fob);

if (!lineobj || !PyUnicode_Check(lineobj)) {

Py_XDECREF(lineobj);

return -1;

}

if (line) {

*line = Py_NewRef(lineobj);

}

/* remove the indentation of the line */

kind = PyUnicode_KIND(lineobj);

data = PyUnicode_DATA(lineobj);

for (i=0; i < PyUnicode_GET_LENGTH(lineobj); i++) {

Py_UCS4 ch = PyUnicode_READ(kind, data, i);

if (ch != ' ' && ch != '\t' && ch != '\014')

break;

}

if (i) {

PyObject *truncated;

truncated = PyUnicode_Substring(lineobj, i, PyUnicode_GET_LENGTH(lineobj));

if (truncated) {

Py_SETREF(lineobj, truncated);

} else {

PyErr_Clear();

}

}

if (truncation != NULL) {

*truncation = i - indent;

}

/* Write some spaces before the line */

if (_Py_WriteIndent(indent, f) < 0) {

goto error;

}

/* finally display the line */

if (PyFile_WriteObject(lineobj, f, Py_PRINT_RAW) < 0) {

goto error;

}

if (PyFile_WriteString("\n", f) < 0) {

goto error;

}

Py_DECREF(lineobj);

return 0;

error:

Py_DECREF(lineobj);

return -1;

}

_Py_DisplaySourceLine(PyObject *f, PyObject *filename, int lineno, int indent,

int *truncation, PyObject **line)

{

return display_source_line(f, filename, lineno, indent, truncation, line);

}

#define IS_WHITESPACE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\f'))

#define _TRACEBACK_SOURCE_LINE_INDENT 4

static inline int

ignore_source_errors(void) {

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt)) {

return -1;

}

PyErr_Clear();

}

return 0;

}

static int

tb_displayline(PyTracebackObject* tb, PyObject *f, PyObject *filename, int lineno,

PyFrameObject *frame, PyObject *name)

{

if (filename == NULL || name == NULL) {

return -1;

}

PyObject *line = PyUnicode_FromFormat(" File \"%U\", line %d, in %U\n",

filename, lineno, name);

if (line == NULL) {

return -1;

}

int res = PyFile_WriteObject(line, f, Py_PRINT_RAW);

Py_DECREF(line);

if (res < 0) {

return -1;

}

int err = 0;

int truncation = _TRACEBACK_SOURCE_LINE_INDENT;

PyObject* source_line = NULL;

int rc = display_source_line(

f, filename, lineno, _TRACEBACK_SOURCE_LINE_INDENT,

&truncation, &source_line);

if (rc != 0 || !source_line) {

/* ignore errors since we can't report them, can we? */

err = ignore_source_errors();

}

Py_XDECREF(source_line);

return err;

}

static const int TB_RECURSIVE_CUTOFF = 3; // Also hardcoded in traceback.py.

static int

tb_print_line_repeated(PyObject *f, long cnt)

{

cnt -= TB_RECURSIVE_CUTOFF;

PyObject *line = PyUnicode_FromFormat(

(cnt > 1)

? " [Previous line repeated %ld more times]\n"

: " [Previous line repeated %ld more time]\n",

cnt);

if (line == NULL) {

return -1;

}

int err = PyFile_WriteObject(line, f, Py_PRINT_RAW);

Py_DECREF(line);

return err;

}

static int

tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)

{

PyCodeObject *code = NULL;

Py_ssize_t depth = 0;

PyObject *last_file = NULL;

int last_line = -1;

PyObject *last_name = NULL;

long cnt = 0;

PyTracebackObject *tb1 = tb;

while (tb1 != NULL) {

depth++;

tb1 = tb1->tb_next;

}

while (tb != NULL && depth > limit) {

depth--;

tb = tb->tb_next;

}

while (tb != NULL) {

code = PyFrame_GetCode(tb->tb_frame);

int tb_lineno = tb->tb_lineno;

if (tb_lineno == -1) {

tb_lineno = tb_get_lineno((PyObject *)tb);

}

if (last_file == NULL ||

code->co_filename != last_file ||

last_line == -1 || tb_lineno != last_line ||

last_name == NULL || code->co_name != last_name) {

if (cnt > TB_RECURSIVE_CUTOFF) {

if (tb_print_line_repeated(f, cnt) < 0) {

goto error;

}

}

last_file = code->co_filename;

last_line = tb_lineno;

last_name = code->co_name;

cnt = 0;

}

cnt++;

if (cnt <= TB_RECURSIVE_CUTOFF) {

if (tb_displayline(tb, f, code->co_filename, tb_lineno,

tb->tb_frame, code->co_name) < 0) {

goto error;

}

if (PyErr_CheckSignals() < 0) {

goto error;

}

}

Py_CLEAR(code);

tb = tb->tb_next;

}

if (cnt > TB_RECURSIVE_CUTOFF) {

if (tb_print_line_repeated(f, cnt) < 0) {

goto error;

}

}

return 0;

error:

Py_XDECREF(code);

return -1;

}

#define PyTraceBack_LIMIT 1000

_PyTraceBack_Print(PyObject *v, const char *header, PyObject *f)

{

PyObject *limitv;

long limit = PyTraceBack_LIMIT;

if (v == NULL) {

return 0;

}

if (!PyTraceBack_Check(v)) {

PyErr_BadInternalCall();

return -1;

}

if (PySys_GetOptionalAttrString("tracebacklimit", &limitv) < 0) {

return -1;

}

else if (limitv != NULL && PyLong_Check(limitv)) {

int overflow;

limit = PyLong_AsLongAndOverflow(limitv, &overflow);

if (overflow > 0) {

limit = LONG_MAX;

}

else if (limit <= 0) {

Py_DECREF(limitv);

return 0;

}

}

Py_XDECREF(limitv);

if (PyFile_WriteString(header, f) < 0) {

return -1;

}

if (tb_printinternal((PyTracebackObject *)v, f, limit) < 0) {

return -1;

}

return 0;

}

PyTraceBack_Print(PyObject *v, PyObject *f)

{

const char *header = EXCEPTION_TB_HEADER;

return _PyTraceBack_Print(v, header, f);

}

_Py_DumpDecimal(int fd, size_t value)

{

/* maximum number of characters required for output of %lld or %p.

char buffer[1 + (sizeof(size_t)*53-1) / 22 + 1];

char *ptr, *end;

end = &buffer[Py_ARRAY_LENGTH(buffer) - 1];

ptr = end;

*ptr = '\0';

do {

--ptr;

assert(ptr >= buffer);

*ptr = '0' + (value % 10);

value /= 10;

} while (value);

(void)_Py_write_noraise(fd, ptr, end - ptr);

}

static void

dump_hexadecimal(int fd, uintptr_t value, Py_ssize_t width, int strip_zeros)

{

char buffer[sizeof(uintptr_t) * 2 + 1], *ptr, *end;

Py_ssize_t size = Py_ARRAY_LENGTH(buffer) - 1;

if (width > size)

width = size;

/* it's ok if width is negative */

end = &buffer[size];

ptr = end;

*ptr = '\0';

do {

--ptr;

assert(ptr >= buffer);

*ptr = Py_hexdigits[value & 15];

value >>= 4;

} while ((end - ptr) < width || value);

size = end - ptr;

if (strip_zeros) {

while (*ptr == '0' && size >= 2) {

ptr++;

size--;

}

}

(void)_Py_write_noraise(fd, ptr, size);

}

_Py_DumpHexadecimal(int fd, uintptr_t value, Py_ssize_t width)

{

dump_hexadecimal(fd, value, width, 0);

}

#ifdef CAN_C_BACKTRACE

static void

dump_pointer(int fd, void *ptr)

{

PUTS(fd, "0x");

dump_hexadecimal(fd, (uintptr_t)ptr, sizeof(void*), 1);

}

static void

dump_char(int fd, char ch)

{

char buf[1] = {ch};

(void)_Py_write_noraise(fd, buf, 1);

}

_Py_DumpASCII(int fd, PyObject *text)

{

PyASCIIObject *ascii = _PyASCIIObject_CAST(text);

Py_ssize_t i, size;

int truncated;

int kind;

void *data = NULL;

Py_UCS4 ch;

if (!PyUnicode_Check(text))

return;

size = ascii->length;

kind = ascii->state.kind;

if (ascii->state.compact) {

if (ascii->state.ascii)

data = ascii + 1;

else

data = _PyCompactUnicodeObject_CAST(text) + 1;

}

else {

data = _PyUnicodeObject_CAST(text)->data.any;

if (data == NULL)

return;

}

if (MAX_STRING_LENGTH < size) {

size = MAX_STRING_LENGTH;

truncated = 1;

}

else {

truncated = 0;

}

// Is an ASCII string?

if (ascii->state.ascii) {

assert(kind == PyUnicode_1BYTE_KIND);

char *str = data;

int need_escape = 0;

for (i=0; i < size; i++) {

ch = str[i];

if (!(' ' <= ch && ch <= 126)) {

need_escape = 1;

break;

}

}

if (!need_escape) {

// The string can be written with a single write() syscall

(void)_Py_write_noraise(fd, str, size);

goto done;

}

}

for (i=0; i < size; i++) {

ch = PyUnicode_READ(kind, data, i);

if (' ' <= ch && ch <= 126) {

/* printable ASCII character */

dump_char(fd, (char)ch);

}

else if (ch <= 0xff) {

PUTS(fd, "\\x");

_Py_DumpHexadecimal(fd, ch, 2);

}

else if (ch <= 0xffff) {

PUTS(fd, "\\u");

_Py_DumpHexadecimal(fd, ch, 4);

}

else {

PUTS(fd, "\\U");

_Py_DumpHexadecimal(fd, ch, 8);

}

}

done:

if (truncated) {

PUTS(fd, "...");

}

}

#ifdef MS_WINDOWS

static void

_Py_DumpWideString(int fd, wchar_t *str)

{

Py_ssize_t size = wcslen(str);

int truncated;

if (MAX_STRING_LENGTH < size) {

size = MAX_STRING_LENGTH;

truncated = 1;

}

else {

truncated = 0;

}

for (Py_ssize_t i=0; i < size; i++) {

Py_UCS4 ch = str[i];

if (' ' <= ch && ch <= 126) {

/* printable ASCII character */

dump_char(fd, (char)ch);

}