/* System module */

/*

Various bits of information used by the interpreter are collected in

module 'sys'.

Function member:

- exit(sts): raise SystemExit

Data members:

- stdin, stdout, stderr: standard file objects

- modules: the table of modules (dictionary)

- path: module search path (list of strings)

- argv: script arguments (list of strings)

- ps1, ps2: optional primary and secondary prompts (strings)

*/

#include "Python.h"

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

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

#include "pycore_dict.h" // _PyDict_GetItemWithError()

#include "pycore_frame.h" // _PyInterpreterFrame

#include "pycore_initconfig.h" // _PyStatus_EXCEPTION()

#include "pycore_long.h" // _PY_LONG_MAX_STR_DIGITS_THRESHOLD

#include "pycore_modsupport.h" // _PyModule_CreateInitialized()

#include "pycore_namespace.h" // _PyNamespace_New()

#include "pycore_object.h" // _PyObject_DebugTypeStats()

#include "pycore_pathconfig.h" // _PyPathConfig_ComputeSysPath0()

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

#include "pycore_pylifecycle.h" // _PyErr_WriteUnraisableDefaultHook()

#include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR

#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()

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

#include "pycore_pystats.h" // _Py_PrintSpecializationStats()

#include "pycore_structseq.h" // _PyStructSequence_InitBuiltinWithFlags()

#include "pycore_sysmodule.h" // export _PySys_GetSizeOf()

#include "pycore_tuple.h" // _PyTuple_FromArray()

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

#include "pydtrace.h" // PyDTrace_AUDIT()

#include "osdefs.h" // DELIM

#include "stdlib_module_names.h" // _Py_stdlib_module_names

#include <locale.h>

#ifdef MS_WINDOWS

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

#endif /* MS_WINDOWS */

#ifdef MS_COREDLL

extern void *PyWin_DLLhModule;

/* A string loaded from the DLL at startup: */

extern const char *PyWin_DLLVersionString;

#endif

#ifdef __EMSCRIPTEN__

# include <emscripten.h>

#endif

#ifdef HAVE_FCNTL_H

# include <fcntl.h>

#endif

/*[clinic input]

module sys

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=3726b388feee8cea]*/

#include "clinic/sysmodule.c.h"

PyObject *

_PySys_GetAttr(PyThreadState *tstate, PyObject *name)

{

PyObject *sd = tstate->interp->sysdict;

if (sd == NULL) {

return NULL;

}

PyObject *exc = _PyErr_GetRaisedException(tstate);

/* XXX Suppress a new exception if it was raised and restore

* the old one. */

PyObject *value = _PyDict_GetItemWithError(sd, name);

_PyErr_SetRaisedException(tstate, exc);

return value;

}

static PyObject *

_PySys_GetObject(PyInterpreterState *interp, const char *name)

{

PyObject *sysdict = interp->sysdict;

if (sysdict == NULL) {

return NULL;

}

PyObject *value;

if (PyDict_GetItemStringRef(sysdict, name, &value) != 1) {

return NULL;

}

Py_DECREF(value); // return a borrowed reference

return value;

}

PyObject *

PySys_GetObject(const char *name)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *exc = _PyErr_GetRaisedException(tstate);

PyObject *value = _PySys_GetObject(tstate->interp, name);

/* XXX Suppress a new exception if it was raised and restore

* the old one. */

_PyErr_SetRaisedException(tstate, exc);

return value;

}

static int

sys_set_object(PyInterpreterState *interp, PyObject *key, PyObject *v)

{

if (key == NULL) {

return -1;

}

PyObject *sd = interp->sysdict;

if (v == NULL) {

v = _PyDict_Pop(sd, key, Py_None);

if (v == NULL) {

return -1;

}

Py_DECREF(v);

return 0;

}

else {

return PyDict_SetItem(sd, key, v);

}

}

int

_PySys_SetAttr(PyObject *key, PyObject *v)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return sys_set_object(interp, key, v);

}

static int

sys_set_object_str(PyInterpreterState *interp, const char *name, PyObject *v)

{

PyObject *key = v ? PyUnicode_InternFromString(name)

: PyUnicode_FromString(name);

int r = sys_set_object(interp, key, v);

Py_XDECREF(key);

return r;

}

int

PySys_SetObject(const char *name, PyObject *v)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return sys_set_object_str(interp, name, v);

}

int

_PySys_ClearAttrString(PyInterpreterState *interp,

const char *name, int verbose)

{

if (verbose) {

PySys_WriteStderr("# clear sys.%s\n", name);

}

/* To play it safe, we set the attr to None instead of deleting it. */

if (PyDict_SetItemString(interp->sysdict, name, Py_None) < 0) {

return -1;

}

return 0;

}

static int

should_audit(PyInterpreterState *interp)

{

/* interp must not be NULL, but test it just in case for extra safety */

assert(interp != NULL);

if (!interp) {

return 0;

}

return (interp->runtime->audit_hooks.head

|| interp->audit_hooks

|| PyDTrace_AUDIT_ENABLED());

}

static int

sys_audit_tstate(PyThreadState *ts, const char *event,

const char *argFormat, va_list vargs)

{

/* N format is inappropriate, because you do not know

whether the reference is consumed by the call.

Assert rather than exception for perf reasons */

assert(!argFormat || !strchr(argFormat, 'N'));

if (!ts) {

/* Audit hooks cannot be called with a NULL thread state */

return 0;

}

/* The current implementation cannot be called if tstate is not

the current Python thread state. */

assert(ts == _PyThreadState_GET());

/* Early exit when no hooks are registered */

PyInterpreterState *is = ts->interp;

if (!should_audit(is)) {

return 0;

}

PyObject *eventName = NULL;

PyObject *eventArgs = NULL;

PyObject *hooks = NULL;

PyObject *hook = NULL;

int res = -1;

int dtrace = PyDTrace_AUDIT_ENABLED();

PyObject *exc = _PyErr_GetRaisedException(ts);

/* Initialize event args now */

if (argFormat && argFormat[0]) {

eventArgs = Py_VaBuildValue(argFormat, vargs);

if (eventArgs && !PyTuple_Check(eventArgs)) {

PyObject *argTuple = PyTuple_Pack(1, eventArgs);

Py_SETREF(eventArgs, argTuple);

}

}

else {

eventArgs = PyTuple_New(0);

}

if (!eventArgs) {

goto exit;

}

/* Call global hooks

*

* We don't worry about any races on hooks getting added,

* since that would not leave is in an inconsistent state. */

_Py_AuditHookEntry *e = is->runtime->audit_hooks.head;

for (; e; e = e->next) {

if (e->hookCFunction(event, eventArgs, e->userData) < 0) {

goto exit;

}

}

/* Dtrace USDT point */

if (dtrace) {

PyDTrace_AUDIT(event, (void *)eventArgs);

}

/* Call interpreter hooks */

if (is->audit_hooks) {

eventName = PyUnicode_FromString(event);

if (!eventName) {

goto exit;

}

hooks = PyObject_GetIter(is->audit_hooks);

if (!hooks) {

goto exit;

}

/* Disallow tracing in hooks unless explicitly enabled */

PyThreadState_EnterTracing(ts);

while ((hook = PyIter_Next(hooks)) != NULL) {

PyObject *o;

int canTrace = PyObject_GetOptionalAttr(hook, &_Py_ID(__cantrace__), &o);

if (o) {

canTrace = PyObject_IsTrue(o);

Py_DECREF(o);

}

if (canTrace < 0) {

break;

}

if (canTrace) {

PyThreadState_LeaveTracing(ts);

}

PyObject* args[2] = {eventName, eventArgs};

o = _PyObject_VectorcallTstate(ts, hook, args, 2, NULL);

if (canTrace) {

PyThreadState_EnterTracing(ts);

}

if (!o) {

break;

}

Py_DECREF(o);

Py_CLEAR(hook);

}

PyThreadState_LeaveTracing(ts);

if (_PyErr_Occurred(ts)) {

goto exit;

}

}

res = 0;

exit:

Py_XDECREF(hook);

Py_XDECREF(hooks);

Py_XDECREF(eventName);

Py_XDECREF(eventArgs);

if (!res) {

_PyErr_SetRaisedException(ts, exc);

}

else {

assert(_PyErr_Occurred(ts));

Py_XDECREF(exc);

}

return res;

}

int

_PySys_Audit(PyThreadState *tstate, const char *event,

const char *argFormat, ...)

{

va_list vargs;

va_start(vargs, argFormat);

int res = sys_audit_tstate(tstate, event, argFormat, vargs);

va_end(vargs);

return res;

}

int

PySys_Audit(const char *event, const char *argFormat, ...)

{

PyThreadState *tstate = _PyThreadState_GET();

va_list vargs;

va_start(vargs, argFormat);

int res = sys_audit_tstate(tstate, event, argFormat, vargs);

va_end(vargs);

return res;

}

/* We expose this function primarily for our own cleanup during

* finalization. In general, it should not need to be called,

* and as such the function is not exported.

*

* Must be finalizing to clear hooks */

void

_PySys_ClearAuditHooks(PyThreadState *ts)

{

assert(ts != NULL);

if (!ts) {

return;

}

_PyRuntimeState *runtime = ts->interp->runtime;

/* The hooks are global so we have to check for runtime finalization. */

PyThreadState *finalizing = _PyRuntimeState_GetFinalizing(runtime);

assert(finalizing == ts);

if (finalizing != ts) {

return;

}

const PyConfig *config = _PyInterpreterState_GetConfig(ts->interp);

if (config->verbose) {

PySys_WriteStderr("# clear sys.audit hooks\n");

}

/* Hooks can abort later hooks for this event, but cannot

abort the clear operation itself. */

_PySys_Audit(ts, "cpython._PySys_ClearAuditHooks", NULL);

_PyErr_Clear(ts);

/* We don't worry about the very unlikely race right here,

* since it's entirely benign. Nothing else removes entries

* from the list and adding an entry right now would not cause

* any trouble. */

_Py_AuditHookEntry *e = runtime->audit_hooks.head, *n;

runtime->audit_hooks.head = NULL;

while (e) {

n = e->next;

PyMem_RawFree(e);

e = n;

}

}

static void

add_audit_hook_entry_unlocked(_PyRuntimeState *runtime,

_Py_AuditHookEntry *entry)

{

if (runtime->audit_hooks.head == NULL) {

runtime->audit_hooks.head = entry;

}

else {

_Py_AuditHookEntry *last = runtime->audit_hooks.head;

while (last->next) {

last = last->next;

}

last->next = entry;

}

}

int

PySys_AddAuditHook(Py_AuditHookFunction hook, void *userData)

{

/* tstate can be NULL, so access directly _PyRuntime:

PySys_AddAuditHook() can be called before Python is initialized. */

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate;

if (runtime->initialized) {

tstate = _PyThreadState_GET();

}

else {

tstate = NULL;

}

/* Invoke existing audit hooks to allow them an opportunity to abort. */

/* Cannot invoke hooks until we are initialized */

if (tstate != NULL) {

if (_PySys_Audit(tstate, "sys.addaudithook", NULL) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_RuntimeError)) {

/* We do not report errors derived from RuntimeError */

_PyErr_Clear(tstate);

return 0;

}

return -1;

}

}

_Py_AuditHookEntry *e = (_Py_AuditHookEntry*)PyMem_RawMalloc(

sizeof(_Py_AuditHookEntry));

if (!e) {

if (tstate != NULL) {

_PyErr_NoMemory(tstate);

}

return -1;

}

e->next = NULL;

e->hookCFunction = (Py_AuditHookFunction)hook;

e->userData = userData;

if (runtime->audit_hooks.mutex == NULL) {

/* The runtime must not be initialized yet. */

add_audit_hook_entry_unlocked(runtime, e);

}

else {

PyThread_acquire_lock(runtime->audit_hooks.mutex, WAIT_LOCK);

add_audit_hook_entry_unlocked(runtime, e);

PyThread_release_lock(runtime->audit_hooks.mutex);

}

return 0;

}

/*[clinic input]

sys.addaudithook

hook: object

Adds a new audit hook callback.

[clinic start generated code]*/

static PyObject *

sys_addaudithook_impl(PyObject *module, PyObject *hook)

/*[clinic end generated code: output=4f9c17aaeb02f44e input=0f3e191217a45e34]*/

{

PyThreadState *tstate = _PyThreadState_GET();

/* Invoke existing audit hooks to allow them an opportunity to abort. */

if (_PySys_Audit(tstate, "sys.addaudithook", NULL) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_Exception)) {

/* We do not report errors derived from Exception */

_PyErr_Clear(tstate);

Py_RETURN_NONE;

}

return NULL;

}

PyInterpreterState *interp = tstate->interp;

if (interp->audit_hooks == NULL) {

interp->audit_hooks = PyList_New(0);

if (interp->audit_hooks == NULL) {

return NULL;

}

/* Avoid having our list of hooks show up in the GC module */

PyObject_GC_UnTrack(interp->audit_hooks);

}

if (PyList_Append(interp->audit_hooks, hook) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(audit_doc,

"audit(event, *args)\n\

\n\

Passes the event to any audit hooks that are attached.");

static PyObject *

sys_audit(PyObject *self, PyObject *const *args, Py_ssize_t argc)

{

PyThreadState *tstate = _PyThreadState_GET();

_Py_EnsureTstateNotNULL(tstate);

if (argc == 0) {

_PyErr_SetString(tstate, PyExc_TypeError,

"audit() missing 1 required positional argument: "

"'event'");

return NULL;

}

if (!should_audit(tstate->interp)) {

Py_RETURN_NONE;

}

PyObject *auditEvent = args[0];

if (!auditEvent) {

_PyErr_SetString(tstate, PyExc_TypeError,

"expected str for argument 'event'");

return NULL;

}

if (!PyUnicode_Check(auditEvent)) {

_PyErr_Format(tstate, PyExc_TypeError,

"expected str for argument 'event', not %.200s",

Py_TYPE(auditEvent)->tp_name);

return NULL;

}

const char *event = PyUnicode_AsUTF8(auditEvent);

if (!event) {

return NULL;

}

PyObject *auditArgs = _PyTuple_FromArray(args + 1, argc - 1);

if (!auditArgs) {

return NULL;

}

int res = _PySys_Audit(tstate, event, "O", auditArgs);

Py_DECREF(auditArgs);

if (res < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

sys_breakpointhook(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *keywords)

{

PyThreadState *tstate = _PyThreadState_GET();

assert(!_PyErr_Occurred(tstate));

char *envar = Py_GETENV("PYTHONBREAKPOINT");

if (envar == NULL || strlen(envar) == 0) {

envar = "pdb.set_trace";

}

else if (!strcmp(envar, "0")) {

/* The breakpoint is explicitly no-op'd. */

Py_RETURN_NONE;

}

/* According to POSIX the string returned by getenv() might be invalidated

* or the string content might be overwritten by a subsequent call to

* getenv(). Since importing a module can performs the getenv() calls,

* we need to save a copy of envar. */

envar = _PyMem_RawStrdup(envar);

if (envar == NULL) {

_PyErr_NoMemory(tstate);

return NULL;

}

const char *last_dot = strrchr(envar, '.');

const char *attrname = NULL;

PyObject *modulepath = NULL;

if (last_dot == NULL) {

/* The breakpoint is a built-in, e.g. PYTHONBREAKPOINT=int */

modulepath = PyUnicode_FromString("builtins");

attrname = envar;

}

else if (last_dot != envar) {

/* Split on the last dot; */

modulepath = PyUnicode_FromStringAndSize(envar, last_dot - envar);

attrname = last_dot + 1;

}

else {

goto warn;

}

if (modulepath == NULL) {

PyMem_RawFree(envar);

return NULL;

}

PyObject *module = PyImport_Import(modulepath);

Py_DECREF(modulepath);

if (module == NULL) {

if (_PyErr_ExceptionMatches(tstate, PyExc_ImportError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyObject *hook = PyObject_GetAttrString(module, attrname);

Py_DECREF(module);

if (hook == NULL) {

if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyMem_RawFree(envar);

PyObject *retval = PyObject_Vectorcall(hook, args, nargs, keywords);

Py_DECREF(hook);

return retval;

warn:

/* If any of the imports went wrong, then warn and ignore. */

_PyErr_Clear(tstate);

int status = PyErr_WarnFormat(

PyExc_RuntimeWarning, 0,

"Ignoring unimportable $PYTHONBREAKPOINT: \"%s\"", envar);

PyMem_RawFree(envar);

if (status < 0) {

/* Printing the warning raised an exception. */

return NULL;

}

/* The warning was (probably) issued. */

Py_RETURN_NONE;

}

PyDoc_STRVAR(breakpointhook_doc,

"breakpointhook(*args, **kws)\n"

"\n"

"This hook function is called by built-in breakpoint().\n"

);

/* Write repr(o) to sys.stdout using sys.stdout.encoding and 'backslashreplace'

error handler. If sys.stdout has a buffer attribute, use

sys.stdout.buffer.write(encoded), otherwise redecode the string and use

sys.stdout.write(redecoded).

Helper function for sys_displayhook(). */

static int

sys_displayhook_unencodable(PyObject *outf, PyObject *o)

{

PyObject *stdout_encoding = NULL;

PyObject *encoded, *escaped_str, *repr_str, *buffer, *result;

const char *stdout_encoding_str;

int ret;

stdout_encoding = PyObject_GetAttr(outf, &_Py_ID(encoding));

if (stdout_encoding == NULL)

goto error;

stdout_encoding_str = PyUnicode_AsUTF8(stdout_encoding);

if (stdout_encoding_str == NULL)

goto error;

repr_str = PyObject_Repr(o);

if (repr_str == NULL)

goto error;

encoded = PyUnicode_AsEncodedString(repr_str,

stdout_encoding_str,

"backslashreplace");

Py_DECREF(repr_str);

if (encoded == NULL)

goto error;

if (PyObject_GetOptionalAttr(outf, &_Py_ID(buffer), &buffer) < 0) {

Py_DECREF(encoded);

goto error;

}

if (buffer) {

result = PyObject_CallMethodOneArg(buffer, &_Py_ID(write), encoded);

Py_DECREF(buffer);

Py_DECREF(encoded);

if (result == NULL)

goto error;

Py_DECREF(result);

}

else {

escaped_str = PyUnicode_FromEncodedObject(encoded,

stdout_encoding_str,

"strict");

Py_DECREF(encoded);

if (PyFile_WriteObject(escaped_str, outf, Py_PRINT_RAW) != 0) {

Py_DECREF(escaped_str);

goto error;

}

Py_DECREF(escaped_str);

}

ret = 0;

goto finally;

error:

ret = -1;

finally:

Py_XDECREF(stdout_encoding);

return ret;

}

/*[clinic input]

sys.displayhook

object as o: object

/

Print an object to sys.stdout and also save it in builtins._

[clinic start generated code]*/

static PyObject *

sys_displayhook(PyObject *module, PyObject *o)

/*[clinic end generated code: output=347477d006df92ed input=08ba730166d7ef72]*/

{

PyObject *outf;

PyObject *builtins;

PyThreadState *tstate = _PyThreadState_GET();

builtins = PyImport_GetModule(&_Py_ID(builtins));

if (builtins == NULL) {

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"lost builtins module");

}

return NULL;

}

Py_DECREF(builtins);

/* Print value except if None */

/* After printing, also assign to '_' */

/* Before, set '_' to None to avoid recursion */

if (o == Py_None) {

Py_RETURN_NONE;

}

if (PyObject_SetAttr(builtins, &_Py_ID(_), Py_None) != 0)

return NULL;

outf = _PySys_GetAttr(tstate, &_Py_ID(stdout));

if (outf == NULL || outf == Py_None) {

_PyErr_SetString(tstate, PyExc_RuntimeError, "lost sys.stdout");

return NULL;

}

if (PyFile_WriteObject(o, outf, 0) != 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_UnicodeEncodeError)) {

int err;

/* repr(o) is not encodable to sys.stdout.encoding with

* sys.stdout.errors error handler (which is probably 'strict') */

_PyErr_Clear(tstate);

err = sys_displayhook_unencodable(outf, o);

if (err) {

return NULL;

}

}

else {

return NULL;

}

}

_Py_DECLARE_STR(newline, "\n");

if (PyFile_WriteObject(&_Py_STR(newline), outf, Py_PRINT_RAW) != 0)

return NULL;

if (PyObject_SetAttr(builtins, &_Py_ID(_), o) != 0)

return NULL;

Py_RETURN_NONE;

}

/*[clinic input]

sys.excepthook

exctype: object

value: object

traceback: object

/

Handle an exception by displaying it with a traceback on sys.stderr.

[clinic start generated code]*/

static PyObject *

sys_excepthook_impl(PyObject *module, PyObject *exctype, PyObject *value,

PyObject *traceback)

/*[clinic end generated code: output=18d99fdda21b6b5e input=ecf606fa826f19d9]*/

{

PyErr_Display(NULL, value, traceback);

Py_RETURN_NONE;

}

/*[clinic input]

sys.exception

Return the current exception.

Return the most recent exception caught by an except clause

in the current stack frame or in an older stack frame, or None

if no such exception exists.

[clinic start generated code]*/

static PyObject *

sys_exception_impl(PyObject *module)

/*[clinic end generated code: output=2381ee2f25953e40 input=c88fbb94b6287431]*/

{

_PyErr_StackItem *err_info = _PyErr_GetTopmostException(_PyThreadState_GET());

if (err_info->exc_value != NULL) {

return Py_NewRef(err_info->exc_value);

}

Py_RETURN_NONE;

}

/*[clinic input]

sys.exc_info

Return current exception information: (type, value, traceback).

Return information about the most recent exception caught by an except

clause in the current stack frame or in an older stack frame.

[clinic start generated code]*/

static PyObject *

sys_exc_info_impl(PyObject *module)

/*[clinic end generated code: output=3afd0940cf3a4d30 input=b5c5bf077788a3e5]*/

{

_PyErr_StackItem *err_info = _PyErr_GetTopmostException(_PyThreadState_GET());

return _PyErr_StackItemToExcInfoTuple(err_info);

}

/*[clinic input]

sys.unraisablehook

unraisable: object

/

Handle an unraisable exception.

The unraisable argument has the following attributes:

* exc_type: Exception type.

* exc_value: Exception value, can be None.

* exc_traceback: Exception traceback, can be None.

* err_msg: Error message, can be None.

* object: Object causing the exception, can be None.

[clinic start generated code]*/

static PyObject *

sys_unraisablehook(PyObject *module, PyObject *unraisable)

/*[clinic end generated code: output=bb92838b32abaa14 input=ec3af148294af8d3]*/

{

return _PyErr_WriteUnraisableDefaultHook(unraisable);

}

/*[clinic input]

sys.exit

status: object = None

/

Exit the interpreter by raising SystemExit(status).

If the status is omitted or None, it defaults to zero (i.e., success).

If the status is an integer, it will be used as the system exit status.

If it is another kind of object, it will be printed and the system

exit status will be one (i.e., failure).

[clinic start generated code]*/

static PyObject *

sys_exit_impl(PyObject *module, PyObject *status)

/*[clinic end generated code: output=13870986c1ab2ec0 input=b86ca9497baa94f2]*/

{

/* Raise SystemExit so callers may catch it or clean up. */

PyErr_SetObject(PyExc_SystemExit, status);

return NULL;

}

static PyObject *

get_utf8_unicode(void)

{

_Py_DECLARE_STR(utf_8, "utf-8");

PyObject *ret = &_Py_STR(utf_8);

return Py_NewRef(ret);

}

/*[clinic input]

sys.getdefaultencoding

Return the current default encoding used by the Unicode implementation.

[clinic start generated code]*/

static PyObject *

sys_getdefaultencoding_impl(PyObject *module)

/*[clinic end generated code: output=256d19dfcc0711e6 input=d416856ddbef6909]*/

{

return get_utf8_unicode();

}

/*[clinic input]

sys.getfilesystemencoding

Return the encoding used to convert Unicode filenames to OS filenames.

[clinic start generated code]*/

static PyObject *

sys_getfilesystemencoding_impl(PyObject *module)

/*[clinic end generated code: output=1dc4bdbe9be44aa7 input=8475f8649b8c7d8c]*/

{

PyInterpreterState *interp = _PyInterpreterState_GET();

const PyConfig *config = _PyInterpreterState_GetConfig(interp);

if (wcscmp(config->filesystem_encoding, L"utf-8") == 0) {

return get_utf8_unicode();

}

PyObject *u = PyUnicode_FromWideChar(config->filesystem_encoding, -1);

if (u == NULL) {

return NULL;

}

_PyUnicode_InternInPlace(interp, &u);

return u;

}

/*[clinic input]

sys.getfilesystemencodeerrors

Return the error mode used Unicode to OS filename conversion.

[clinic start generated code]*/

static PyObject *

sys_getfilesystemencodeerrors_impl(PyObject *module)

/*[clinic end generated code: output=ba77b36bbf7c96f5 input=22a1e8365566f1e5]*/

{

PyInterpreterState *interp = _PyInterpreterState_GET();

const PyConfig *config = _PyInterpreterState_GetConfig(interp);

PyObject *u = PyUnicode_FromWideChar(config->filesystem_errors, -1);

if (u == NULL) {

return NULL;

}

_PyUnicode_InternInPlace(interp, &u);

return u;

}

/*[clinic input]

sys.intern

string as s: unicode

/

``Intern'' the given string.

This enters the string in the (global) table of interned strings whose

purpose is to speed up dictionary lookups. Return the string itself or

the previously interned string object with the same value.

[clinic start generated code]*/

static PyObject *

sys_intern_impl(PyObject *module, PyObject *s)

/*[clinic end generated code: output=be680c24f5c9e5d6 input=849483c006924e2f]*/

{

if (PyUnicode_CheckExact(s)) {

Py_INCREF(s);

PyUnicode_InternInPlace(&s);

return s;

}

else {

PyErr_Format(PyExc_TypeError,

"can't intern %.400s", Py_TYPE(s)->tp_name);

return NULL;

}

}

/*

* Cached interned string objects used for calling the profile and

* trace functions.

*/

static PyObject *whatstrings[8] = {

&_Py_ID(call),

&_Py_ID(exception),

&_Py_ID(line),

&_Py_ID(return),

&_Py_ID(c_call),

&_Py_ID(c_exception),

&_Py_ID(c_return),

&_Py_ID(opcode),

};

static PyObject *

call_trampoline(PyThreadState *tstate, PyObject* callback,

PyFrameObject *frame, int what, PyObject *arg)

{

/* Discard any previous modifications the frame's fast locals */

if (frame->f_fast_as_locals) {

if (PyFrame_FastToLocalsWithError(frame) < 0) {

return NULL;

}

}

/* call the Python-level function */