/* Top level execution of Python code (including in __main__) */

/* To help control the interfaces between the startup, execution and

* shutdown code, the phases are split across separate modules (boostrap,

* pythonrun, shutdown)

*/

/* TODO: Cull includes following phase split */

#include "Python.h"

#include "Python-ast.h"

#undef Yield /* undefine macro conflicting with winbase.h */

#include "internal/pystate.h"

#include "grammar.h"

#include "node.h"

#include "token.h"

#include "parsetok.h"

#include "errcode.h"

#include "code.h"

#include "symtable.h"

#include "ast.h"

#include "marshal.h"

#include "osdefs.h"

#include <locale.h>

#ifdef HAVE_SIGNAL_H

#include <signal.h>

#endif

#ifdef MS_WINDOWS

#include "malloc.h" /* for alloca */

#endif

#ifdef MS_WINDOWS

#undef BYTE

#include "windows.h"

#endif

_Py_IDENTIFIER(builtins);

_Py_IDENTIFIER(excepthook);

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(last_traceback);

_Py_IDENTIFIER(last_type);

_Py_IDENTIFIER(last_value);

_Py_IDENTIFIER(ps1);

_Py_IDENTIFIER(ps2);

_Py_IDENTIFIER(stdin);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

_Py_static_string(PyId_string, "<string>");

#ifdef __cplusplus

extern "C" {

#endif

extern grammar _PyParser_Grammar; /* From graminit.c */

/* Forward */

static void flush_io(void);

static PyObject *run_mod(mod_ty, PyObject *, PyObject *, PyObject *,

PyCompilerFlags *, PyArena *);

static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,

PyCompilerFlags *);

static void err_input(perrdetail *);

static void err_free(perrdetail *);

/* Parse input from a file and execute it */

int

PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,

PyCompilerFlags *flags)

{

if (filename == NULL)

filename = "???";

if (Py_FdIsInteractive(fp, filename)) {

int err = PyRun_InteractiveLoopFlags(fp, filename, flags);

if (closeit)

fclose(fp);

return err;

}

else

return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);

}

int

PyRun_InteractiveLoopFlags(FILE *fp, const char *filename_str, PyCompilerFlags *flags)

{

PyObject *filename, *v;

int ret, err;

PyCompilerFlags local_flags;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL) {

PyErr_Print();

return -1;

}

if (flags == NULL) {

flags = &local_flags;

local_flags.cf_flags = 0;

}

v = _PySys_GetObjectId(&PyId_ps1);

if (v == NULL) {

_PySys_SetObjectId(&PyId_ps1, v = PyUnicode_FromString(">>> "));

Py_XDECREF(v);

}

v = _PySys_GetObjectId(&PyId_ps2);

if (v == NULL) {

_PySys_SetObjectId(&PyId_ps2, v = PyUnicode_FromString("... "));

Py_XDECREF(v);

}

err = -1;

for (;;) {

ret = PyRun_InteractiveOneObject(fp, filename, flags);

#ifdef Py_REF_DEBUG

if (_PyDebug_XOptionShowRefCount() == Py_True)

_PyDebug_PrintTotalRefs();

#endif

if (ret == E_EOF) {

err = 0;

break;

}

/*

if (ret == E_NOMEM)

break;

*/

}

Py_DECREF(filename);

return err;

}

/* compute parser flags based on compiler flags */

static int PARSER_FLAGS(PyCompilerFlags *flags)

{

int parser_flags = 0;

if (!flags)

return 0;

if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT)

parser_flags |= PyPARSE_DONT_IMPLY_DEDENT;

if (flags->cf_flags & PyCF_IGNORE_COOKIE)

parser_flags |= PyPARSE_IGNORE_COOKIE;

if (flags->cf_flags & CO_FUTURE_BARRY_AS_BDFL)

parser_flags |= PyPARSE_BARRY_AS_BDFL;

return parser_flags;

}

#if 0

/* Keep an example of flags with future keyword support. */

#define PARSER_FLAGS(flags) \

((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \

PyPARSE_DONT_IMPLY_DEDENT : 0) \

| ((flags)->cf_flags & CO_FUTURE_WITH_STATEMENT ? \

PyPARSE_WITH_IS_KEYWORD : 0)) : 0)

#endif

int

PyRun_InteractiveOneObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags)

{

PyObject *m, *d, *v, *w, *oenc = NULL, *mod_name;

mod_ty mod;

PyArena *arena;

const char *ps1 = "", *ps2 = "", *enc = NULL;

int errcode = 0;

_Py_IDENTIFIER(encoding);

_Py_IDENTIFIER(__main__);

mod_name = _PyUnicode_FromId(&PyId___main__); /* borrowed */

if (mod_name == NULL) {

PyErr_Print();

return -1;

}

if (fp == stdin) {

/* Fetch encoding from sys.stdin if possible. */

v = _PySys_GetObjectId(&PyId_stdin);

if (v && v != Py_None) {

oenc = _PyObject_GetAttrId(v, &PyId_encoding);

if (oenc)

enc = PyUnicode_AsUTF8(oenc);

if (!enc)

PyErr_Clear();

}

}

v = _PySys_GetObjectId(&PyId_ps1);

if (v != NULL) {

v = PyObject_Str(v);

if (v == NULL)

PyErr_Clear();

else if (PyUnicode_Check(v)) {

ps1 = PyUnicode_AsUTF8(v);

if (ps1 == NULL) {

PyErr_Clear();

ps1 = "";

}

}

}

w = _PySys_GetObjectId(&PyId_ps2);

if (w != NULL) {

w = PyObject_Str(w);

if (w == NULL)

PyErr_Clear();

else if (PyUnicode_Check(w)) {

ps2 = PyUnicode_AsUTF8(w);

if (ps2 == NULL) {

PyErr_Clear();

ps2 = "";

}

}

}

arena = PyArena_New();

if (arena == NULL) {

Py_XDECREF(v);

Py_XDECREF(w);

Py_XDECREF(oenc);

return -1;

}

mod = PyParser_ASTFromFileObject(fp, filename, enc,

Py_single_input, ps1, ps2,

flags, &errcode, arena);

Py_XDECREF(v);

Py_XDECREF(w);

Py_XDECREF(oenc);

if (mod == NULL) {

PyArena_Free(arena);

if (errcode == E_EOF) {

PyErr_Clear();

return E_EOF;

}

PyErr_Print();

return -1;

}

m = PyImport_AddModuleObject(mod_name);

if (m == NULL) {

PyArena_Free(arena);

return -1;

}

d = PyModule_GetDict(m);

v = run_mod(mod, filename, d, d, flags, arena);

PyArena_Free(arena);

if (v == NULL) {

PyErr_Print();

flush_io();

return -1;

}

Py_DECREF(v);

flush_io();

return 0;

}

int

PyRun_InteractiveOneFlags(FILE *fp, const char *filename_str, PyCompilerFlags *flags)

{

PyObject *filename;

int res;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL) {

PyErr_Print();

return -1;

}

res = PyRun_InteractiveOneObject(fp, filename, flags);

Py_DECREF(filename);

return res;

}

/* Check whether a file maybe a pyc file: Look at the extension,

the file type, and, if we may close it, at the first few bytes. */

static int

maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)

{

if (strcmp(ext, ".pyc") == 0)

return 1;

/* Only look into the file if we are allowed to close it, since

it then should also be seekable. */

if (closeit) {

/* Read only two bytes of the magic. If the file was opened in

text mode, the bytes 3 and 4 of the magic (\r\n) might not

be read as they are on disk. */

unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;

unsigned char buf[2];

/* Mess: In case of -x, the stream is NOT at its start now,

and ungetc() was used to push back the first newline,

which makes the current stream position formally undefined,

and a x-platform nightmare.

Unfortunately, we have no direct way to know whether -x

was specified. So we use a terrible hack: if the current

stream position is not 0, we assume -x was specified, and

give up. Bug 132850 on SourceForge spells out the

hopelessness of trying anything else (fseek and ftell

don't work predictably x-platform for text-mode files).

*/

int ispyc = 0;

if (ftell(fp) == 0) {

if (fread(buf, 1, 2, fp) == 2 &&

((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)

ispyc = 1;

rewind(fp);

}

return ispyc;

}

return 0;

}

static int

set_main_loader(PyObject *d, const char *filename, const char *loader_name)

{

PyInterpreterState *interp;

PyThreadState *tstate;

PyObject *filename_obj, *bootstrap, *loader_type = NULL, *loader;

int result = 0;

filename_obj = PyUnicode_DecodeFSDefault(filename);

if (filename_obj == NULL)

return -1;

/* Get current thread state and interpreter pointer */

tstate = PyThreadState_GET();

interp = tstate->interp;

bootstrap = PyObject_GetAttrString(interp->importlib,

"_bootstrap_external");

if (bootstrap != NULL) {

loader_type = PyObject_GetAttrString(bootstrap, loader_name);

Py_DECREF(bootstrap);

}

if (loader_type == NULL) {

Py_DECREF(filename_obj);

return -1;

}

loader = PyObject_CallFunction(loader_type, "sN", "__main__", filename_obj);

Py_DECREF(loader_type);

if (loader == NULL) {

return -1;

}

if (PyDict_SetItemString(d, "__loader__", loader) < 0) {

result = -1;

}

Py_DECREF(loader);

return result;

}

int

PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,

PyCompilerFlags *flags)

{

PyObject *m, *d, *v;

const char *ext;

int set_file_name = 0, ret = -1;

size_t len;

m = PyImport_AddModule("__main__");

if (m == NULL)

return -1;

Py_INCREF(m);

d = PyModule_GetDict(m);

if (PyDict_GetItemString(d, "__file__") == NULL) {

PyObject *f;

f = PyUnicode_DecodeFSDefault(filename);

if (f == NULL)

goto done;

if (PyDict_SetItemString(d, "__file__", f) < 0) {

Py_DECREF(f);

goto done;

}

if (PyDict_SetItemString(d, "__cached__", Py_None) < 0) {

Py_DECREF(f);

goto done;

}

set_file_name = 1;

Py_DECREF(f);

}

len = strlen(filename);

ext = filename + len - (len > 4 ? 4 : 0);

if (maybe_pyc_file(fp, filename, ext, closeit)) {

FILE *pyc_fp;

/* Try to run a pyc file. First, re-open in binary */

if (closeit)

fclose(fp);

if ((pyc_fp = _Py_fopen(filename, "rb")) == NULL) {

fprintf(stderr, "python: Can't reopen .pyc file\n");

goto done;

}

if (set_main_loader(d, filename, "SourcelessFileLoader") < 0) {

fprintf(stderr, "python: failed to set __main__.__loader__\n");

ret = -1;

fclose(pyc_fp);

goto done;

}

v = run_pyc_file(pyc_fp, filename, d, d, flags);

fclose(pyc_fp);

} else {

/* When running from stdin, leave __main__.__loader__ alone */

if (strcmp(filename, "<stdin>") != 0 &&

set_main_loader(d, filename, "SourceFileLoader") < 0) {

fprintf(stderr, "python: failed to set __main__.__loader__\n");

ret = -1;

goto done;

}

v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,

closeit, flags);

}

flush_io();

if (v == NULL) {

PyErr_Print();

goto done;

}

Py_DECREF(v);

ret = 0;

done:

if (set_file_name && PyDict_DelItemString(d, "__file__"))

PyErr_Clear();

Py_DECREF(m);

return ret;

}

int

PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)

{

PyObject *m, *d, *v;

m = PyImport_AddModule("__main__");

if (m == NULL)

return -1;

d = PyModule_GetDict(m);

v = PyRun_StringFlags(command, Py_file_input, d, d, flags);

if (v == NULL) {

PyErr_Print();

return -1;

}

Py_DECREF(v);

return 0;

}

static int

parse_syntax_error(PyObject *err, PyObject **message, PyObject **filename,

int *lineno, int *offset, PyObject **text)

{

int hold;

PyObject *v;

_Py_IDENTIFIER(msg);

_Py_IDENTIFIER(filename);

_Py_IDENTIFIER(lineno);

_Py_IDENTIFIER(offset);

_Py_IDENTIFIER(text);

*message = NULL;

*filename = NULL;

/* new style errors. `err' is an instance */

*message = _PyObject_GetAttrId(err, &PyId_msg);

if (!*message)

goto finally;

v = _PyObject_GetAttrId(err, &PyId_filename);

if (!v)

goto finally;

if (v == Py_None) {

Py_DECREF(v);

*filename = _PyUnicode_FromId(&PyId_string);

if (*filename == NULL)

goto finally;

Py_INCREF(*filename);

}

else {

*filename = v;

}

v = _PyObject_GetAttrId(err, &PyId_lineno);

if (!v)

goto finally;

hold = _PyLong_AsInt(v);

Py_DECREF(v);

if (hold < 0 && PyErr_Occurred())

goto finally;

*lineno = hold;

v = _PyObject_GetAttrId(err, &PyId_offset);

if (!v)

goto finally;

if (v == Py_None) {

*offset = -1;

Py_DECREF(v);

} else {

hold = _PyLong_AsInt(v);

Py_DECREF(v);

if (hold < 0 && PyErr_Occurred())

goto finally;

*offset = hold;

}

v = _PyObject_GetAttrId(err, &PyId_text);

if (!v)

goto finally;

if (v == Py_None) {

Py_DECREF(v);

*text = NULL;

}

else {

*text = v;

}

return 1;

finally:

Py_XDECREF(*message);

Py_XDECREF(*filename);

return 0;

}

void

PyErr_Print(void)

{

PyErr_PrintEx(1);

}

static void

print_error_text(PyObject *f, int offset, PyObject *text_obj)

{

const char *text;

const char *nl;

text = PyUnicode_AsUTF8(text_obj);

if (text == NULL)

return;

if (offset >= 0) {

if (offset > 0 && (size_t)offset == strlen(text) && text[offset - 1] == '\n')

offset--;

for (;;) {

nl = strchr(text, '\n');

if (nl == NULL || nl-text >= offset)

break;

offset -= (int)(nl+1-text);

text = nl+1;

}

while (*text == ' ' || *text == '\t' || *text == '\f') {

text++;

offset--;

}

}

PyFile_WriteString(" ", f);

PyFile_WriteString(text, f);

if (*text == '\0' || text[strlen(text)-1] != '\n')

PyFile_WriteString("\n", f);

if (offset == -1)

return;

PyFile_WriteString(" ", f);

while (--offset > 0)

PyFile_WriteString(" ", f);

PyFile_WriteString("^\n", f);

}

static void

handle_system_exit(void)

{

PyObject *exception, *value, *tb;

int exitcode = 0;

if (Py_InspectFlag)

/* Don't exit if -i flag was given. This flag is set to 0

* when entering interactive mode for inspecting. */

return;

PyErr_Fetch(&exception, &value, &tb);

fflush(stdout);

if (value == NULL || value == Py_None)

goto done;

if (PyExceptionInstance_Check(value)) {

/* The error code should be in the `code' attribute. */

_Py_IDENTIFIER(code);

PyObject *code = _PyObject_GetAttrId(value, &PyId_code);

if (code) {

Py_DECREF(value);

value = code;

if (value == Py_None)

goto done;

}

/* If we failed to dig out the 'code' attribute,

just let the else clause below print the error. */

}

if (PyLong_Check(value))

exitcode = (int)PyLong_AsLong(value);

else {

PyObject *sys_stderr = _PySys_GetObjectId(&PyId_stderr);

/* We clear the exception here to avoid triggering the assertion

* in PyObject_Str that ensures it won't silently lose exception

* details.

*/

PyErr_Clear();

if (sys_stderr != NULL && sys_stderr != Py_None) {

PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);

} else {

PyObject_Print(value, stderr, Py_PRINT_RAW);

fflush(stderr);

}

PySys_WriteStderr("\n");

exitcode = 1;

}

done:

/* Restore and clear the exception info, in order to properly decref

* the exception, value, and traceback. If we just exit instead,

* these leak, which confuses PYTHONDUMPREFS output, and may prevent

* some finalizers from running.

*/

PyErr_Restore(exception, value, tb);

PyErr_Clear();

Py_Exit(exitcode);

/* NOTREACHED */

}

void

PyErr_PrintEx(int set_sys_last_vars)

{

PyObject *exception, *v, *tb, *hook;

if (PyErr_ExceptionMatches(PyExc_SystemExit)) {

handle_system_exit();

}

PyErr_Fetch(&exception, &v, &tb);

if (exception == NULL)

return;

PyErr_NormalizeException(&exception, &v, &tb);

if (tb == NULL) {

tb = Py_None;

Py_INCREF(tb);

}

PyException_SetTraceback(v, tb);

if (exception == NULL)

return;

/* Now we know v != NULL too */

if (set_sys_last_vars) {

_PySys_SetObjectId(&PyId_last_type, exception);

_PySys_SetObjectId(&PyId_last_value, v);

_PySys_SetObjectId(&PyId_last_traceback, tb);

}

hook = _PySys_GetObjectId(&PyId_excepthook);

if (hook) {

PyObject* stack[3];

PyObject *result;

stack[0] = exception;

stack[1] = v;

stack[2] = tb;

result = _PyObject_FastCall(hook, stack, 3);

if (result == NULL) {

PyObject *exception2, *v2, *tb2;

if (PyErr_ExceptionMatches(PyExc_SystemExit)) {

handle_system_exit();

}

PyErr_Fetch(&exception2, &v2, &tb2);

PyErr_NormalizeException(&exception2, &v2, &tb2);

/* It should not be possible for exception2 or v2

to be NULL. However PyErr_Display() can't

tolerate NULLs, so just be safe. */

if (exception2 == NULL) {

exception2 = Py_None;

Py_INCREF(exception2);

}

if (v2 == NULL) {

v2 = Py_None;

Py_INCREF(v2);

}

fflush(stdout);

PySys_WriteStderr("Error in sys.excepthook:\n");

PyErr_Display(exception2, v2, tb2);

PySys_WriteStderr("\nOriginal exception was:\n");

PyErr_Display(exception, v, tb);

Py_DECREF(exception2);

Py_DECREF(v2);

Py_XDECREF(tb2);

}

Py_XDECREF(result);

} else {

PySys_WriteStderr("sys.excepthook is missing\n");

PyErr_Display(exception, v, tb);

}

Py_XDECREF(exception);

Py_XDECREF(v);

Py_XDECREF(tb);

}

static void

print_exception(PyObject *f, PyObject *value)

{

int err = 0;

PyObject *type, *tb;

_Py_IDENTIFIER(print_file_and_line);

if (!PyExceptionInstance_Check(value)) {

err = PyFile_WriteString("TypeError: print_exception(): Exception expected for value, ", f);

err += PyFile_WriteString(Py_TYPE(value)->tp_name, f);

err += PyFile_WriteString(" found\n", f);

if (err)

PyErr_Clear();

return;

}

Py_INCREF(value);

fflush(stdout);

type = (PyObject *) Py_TYPE(value);

tb = PyException_GetTraceback(value);

if (tb && tb != Py_None)

err = PyTraceBack_Print(tb, f);

if (err == 0 &&

_PyObject_HasAttrId(value, &PyId_print_file_and_line))

{

PyObject *message, *filename, *text;

int lineno, offset;

if (!parse_syntax_error(value, &message, &filename,

&lineno, &offset, &text))

PyErr_Clear();

else {

PyObject *line;

Py_DECREF(value);

value = message;

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

filename, lineno);

Py_DECREF(filename);

if (line != NULL) {

PyFile_WriteObject(line, f, Py_PRINT_RAW);

Py_DECREF(line);

}

if (text != NULL) {

print_error_text(f, offset, text);

Py_DECREF(text);

}

/* Can't be bothered to check all those

PyFile_WriteString() calls */

if (PyErr_Occurred())

err = -1;

}

}

if (err) {

/* Don't do anything else */

}

else {

PyObject* moduleName;

char* className;

_Py_IDENTIFIER(__module__);

assert(PyExceptionClass_Check(type));

className = PyExceptionClass_Name(type);

if (className != NULL) {

char *dot = strrchr(className, '.');

if (dot != NULL)

className = dot+1;

}

moduleName = _PyObject_GetAttrId(type, &PyId___module__);

if (moduleName == NULL || !PyUnicode_Check(moduleName))

{

Py_XDECREF(moduleName);

err = PyFile_WriteString("<unknown>", f);

}

else {

if (!_PyUnicode_EqualToASCIIId(moduleName, &PyId_builtins))

{

err = PyFile_WriteObject(moduleName, f, Py_PRINT_RAW);

err += PyFile_WriteString(".", f);

}

Py_DECREF(moduleName);

}

if (err == 0) {

if (className == NULL)

err = PyFile_WriteString("<unknown>", f);

else

err = PyFile_WriteString(className, f);

}

}

if (err == 0 && (value != Py_None)) {

PyObject *s = PyObject_Str(value);

/* only print colon if the str() of the

object is not the empty string

*/

if (s == NULL) {

PyErr_Clear();

err = -1;

PyFile_WriteString(": <exception str() failed>", f);

}

else if (!PyUnicode_Check(s) ||

PyUnicode_GetLength(s) != 0)

err = PyFile_WriteString(": ", f);

if (err == 0)

err = PyFile_WriteObject(s, f, Py_PRINT_RAW);

Py_XDECREF(s);

}

/* try to write a newline in any case */

if (err < 0) {

PyErr_Clear();

}

err += PyFile_WriteString("\n", f);

Py_XDECREF(tb);

Py_DECREF(value);

/* If an error happened here, don't show it.

XXX This is wrong, but too many callers rely on this behavior. */

if (err != 0)

PyErr_Clear();

}

static const char cause_message[] =

"\nThe above exception was the direct cause "

"of the following exception:\n\n";

static const char context_message[] =

"\nDuring handling of the above exception, "

"another exception occurred:\n\n";

static void

print_exception_recursive(PyObject *f, PyObject *value, PyObject *seen)

{

int err = 0, res;

PyObject *cause, *context;

if (seen != NULL) {

/* Exception chaining */

PyObject *value_id = PyLong_FromVoidPtr(value);

if (value_id == NULL || PySet_Add(seen, value_id) == -1)

PyErr_Clear();

else if (PyExceptionInstance_Check(value)) {

PyObject *check_id = NULL;

cause = PyException_GetCause(value);

context = PyException_GetContext(value);

if (cause) {

check_id = PyLong_FromVoidPtr(cause);

if (check_id == NULL) {

res = -1;

} else {

res = PySet_Contains(seen, check_id);

Py_DECREF(check_id);

}

if (res == -1)

PyErr_Clear();

if (res == 0) {

print_exception_recursive(

f, cause, seen);

err |= PyFile_WriteString(

cause_message, f);

}

}

else if (context &&

!((PyBaseExceptionObject *)value)->suppress_context) {

check_id = PyLong_FromVoidPtr(context);

if (check_id == NULL) {

res = -1;

} else {

res = PySet_Contains(seen, check_id);

Py_DECREF(check_id);

}

if (res == -1)

PyErr_Clear();

if (res == 0) {

print_exception_recursive(

f, context, seen);

err |= PyFile_WriteString(

context_message, f);

}

}

Py_XDECREF(context);

Py_XDECREF(cause);

}

Py_XDECREF(value_id);

}

print_exception(f, value);

if (err != 0)

PyErr_Clear();

}

void

PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)

{

PyObject *seen;

PyObject *f = _PySys_GetObjectId(&PyId_stderr);

if (PyExceptionInstance_Check(value)

&& tb != NULL && PyTraceBack_Check(tb)) {

/* Put the traceback on the exception, otherwise it won't get

displayed. See issue #18776. */

PyObject *cur_tb = PyException_GetTraceback(value);

if (cur_tb == NULL)

PyException_SetTraceback(value, tb);

else

Py_DECREF(cur_tb);

}

if (f == Py_None) {

/* pass */

}

else if (f == NULL) {

_PyObject_Dump(value);

fprintf(stderr, "lost sys.stderr\n");

}

else {

/* We choose to ignore seen being possibly NULL, and report

at least the main exception (it could be a MemoryError).

*/

seen = PySet_New(NULL);

if (seen == NULL)

PyErr_Clear();

print_exception_recursive(f, value, seen);

Py_XDECREF(seen);

}

}

PyObject *

PyRun_StringFlags(const char *str, int start, PyObject *globals,

PyObject *locals, PyCompilerFlags *flags)

{

PyObject *ret = NULL;

mod_ty mod;

PyArena *arena;

PyObject *filename;

filename = _PyUnicode_FromId(&PyId_string); /* borrowed */

if (filename == NULL)

return NULL;

arena = PyArena_New();

if (arena == NULL)

return NULL;

mod = PyParser_ASTFromStringObject(str, filename, start, flags, arena);

if (mod != NULL)

ret = run_mod(mod, filename, globals, locals, flags, arena);

PyArena_Free(arena);

return ret;

}

PyObject *

PyRun_FileExFlags(FILE *fp, const char *filename_str, int start, PyObject *globals,

PyObject *locals, int closeit, PyCompilerFlags *flags)

{

PyObject *ret = NULL;

mod_ty mod;

PyArena *arena = NULL;

PyObject *filename;

filename = PyUnicode_DecodeFSDefault(filename_str);

if (filename == NULL)

goto exit;

arena = PyArena_New();

if (arena == NULL)

goto exit;

mod = PyParser_ASTFromFileObject(fp, filename, NULL, start, 0, 0,

flags, NULL, arena);

if (closeit)

fclose(fp);

if (mod == NULL) {

goto exit;

}

ret = run_mod(mod, filename, globals, locals, flags, arena);

exit:

Py_XDECREF(filename);

if (arena != NULL)

PyArena_Free(arena);

return ret;

}

static void

flush_io(void)

{

PyObject *f, *r;

PyObject *type, *value, *traceback;

/* Save the current exception */

PyErr_Fetch(&type, &value, &traceback);

f = _PySys_GetObjectId(&PyId_stderr);

if (f != NULL) {

r = _PyObject_CallMethodId(f, &PyId_flush, NULL);

if (r)

Py_DECREF(r);

else

PyErr_Clear();

}

f = _PySys_GetObjectId(&PyId_stdout);

if (f != NULL) {

r = _PyObject_CallMethodId(f, &PyId_flush, NULL);

if (r)

Py_DECREF(r);

else

PyErr_Clear();

}

PyErr_Restore(type, value, traceback);

}

static PyObject *

run_mod(mod_ty mod, PyObject *filename, PyObject *globals, PyObject *locals,

PyCompilerFlags *flags, PyArena *arena)

{

PyCodeObject *co;

PyObject *v;

co = PyAST_CompileObject(mod, filename, flags, -1, arena);

if (co == NULL)

return NULL;