/* 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 "code.h"

#include "frameobject.h"

#include "pycore_ceval.h"

#include "pycore_initconfig.h"

#include "pycore_pathconfig.h"

#include "pycore_pyerrors.h"

#include "pycore_pylifecycle.h"

#include "pycore_pymem.h"

#include "pycore_pystate.h"

#include "pycore_tupleobject.h"

#include "pythread.h"

#include "pydtrace.h"

#include "osdefs.h"

#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

/*[clinic input]

module sys

[clinic start generated code]*/

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

#include "clinic/sysmodule.c.h"

_Py_IDENTIFIER(_);

_Py_IDENTIFIER(__sizeof__);

_Py_IDENTIFIER(_xoptions);

_Py_IDENTIFIER(buffer);

_Py_IDENTIFIER(builtins);

_Py_IDENTIFIER(encoding);

_Py_IDENTIFIER(path);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

_Py_IDENTIFIER(warnoptions);

_Py_IDENTIFIER(write);

static PyObject *

sys_get_object_id(PyThreadState *tstate, _Py_Identifier *key)

{

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

if (sd == NULL) {

return NULL;

}

return _PyDict_GetItemId(sd, key);

}

PyObject *

_PySys_GetObjectId(_Py_Identifier *key)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_get_object_id(tstate, key);

}

PyObject *

PySys_GetObject(const char *name)

{

PyThreadState *tstate = _PyThreadState_GET();

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

if (sd == NULL) {

return NULL;

}

return PyDict_GetItemString(sd, name);

}

static int

sys_set_object_id(PyThreadState *tstate, _Py_Identifier *key, PyObject *v)

{

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

if (v == NULL) {

if (_PyDict_GetItemId(sd, key) == NULL) {

return 0;

}

else {

return _PyDict_DelItemId(sd, key);

}

}

else {

return _PyDict_SetItemId(sd, key, v);

}

}

int

_PySys_SetObjectId(_Py_Identifier *key, PyObject *v)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_set_object_id(tstate, key, v);

}

static int

sys_set_object(PyThreadState *tstate, const char *name, PyObject *v)

{

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

if (v == NULL) {

if (PyDict_GetItemString(sd, name) == NULL) {

return 0;

}

else {

return PyDict_DelItemString(sd, name);

}

}

else {

return PyDict_SetItemString(sd, name, v);

}

}

int

PySys_SetObject(const char *name, PyObject *v)

{

PyThreadState *tstate = _PyThreadState_GET();

return sys_set_object(tstate, name, v);

}

static int

should_audit(PyThreadState *ts)

{

if (!ts) {

return 0;

}

PyInterpreterState *is = ts ? ts->interp : NULL;

return _PyRuntime.audit_hook_head

|| (is && is->audit_hooks)

|| PyDTrace_AUDIT_ENABLED();

}

int

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

{

PyObject *eventName = NULL;

PyObject *eventArgs = NULL;

PyObject *hooks = NULL;

PyObject *hook = NULL;

int res = -1;

PyThreadState *ts = _PyThreadState_GET();

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

/* Early exit when no hooks are registered */

if (!should_audit(ts)) {

return 0;

}

_Py_AuditHookEntry *e = _PyRuntime.audit_hook_head;

int dtrace = PyDTrace_AUDIT_ENABLED();

PyObject *exc_type, *exc_value, *exc_tb;

if (ts) {

_PyErr_Fetch(ts, &exc_type, &exc_value, &exc_tb);

}

/* Initialize event args now */

if (argFormat && argFormat[0]) {

va_list args;

va_start(args, argFormat);

eventArgs = Py_VaBuildValue(argFormat, args);

va_end(args);

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

PyObject *argTuple = PyTuple_Pack(1, eventArgs);

Py_DECREF(eventArgs);

eventArgs = argTuple;

}

} else {

eventArgs = PyTuple_New(0);

}

if (!eventArgs) {

goto exit;

}

/* Call global hooks */

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

PyInterpreterState *is = ts ? ts->interp : NULL;

if (is && 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 */

ts->tracing++;

ts->use_tracing = 0;

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

_Py_IDENTIFIER(__cantrace__);

PyObject *o;

int canTrace = _PyObject_LookupAttrId(hook, &PyId___cantrace__, &o);

if (o) {

canTrace = PyObject_IsTrue(o);

Py_DECREF(o);

}

if (canTrace < 0) {

break;

}

if (canTrace) {

ts->use_tracing = (ts->c_tracefunc || ts->c_profilefunc);

ts->tracing--;

}

o = PyObject_CallFunctionObjArgs(hook, eventName,

eventArgs, NULL);

if (canTrace) {

ts->tracing++;

ts->use_tracing = 0;

}

if (!o) {

break;

}

Py_DECREF(o);

Py_CLEAR(hook);

}

ts->use_tracing = (ts->c_tracefunc || ts->c_profilefunc);

ts->tracing--;

if (_PyErr_Occurred(ts)) {

goto exit;

}

}

res = 0;

exit:

Py_XDECREF(hook);

Py_XDECREF(hooks);

Py_XDECREF(eventName);

Py_XDECREF(eventArgs);

if (ts) {

if (!res) {

_PyErr_Restore(ts, exc_type, exc_value, exc_tb);

} else {

assert(_PyErr_Occurred(ts));

Py_XDECREF(exc_type);

Py_XDECREF(exc_value);

Py_XDECREF(exc_tb);

}

}

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 it is not defined in any header files.

*/

void

_PySys_ClearAuditHooks(void)

{

/* Must be finalizing to clear hooks */

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *ts = _PyRuntimeState_GetThreadState(runtime);

assert(!ts || _Py_CURRENTLY_FINALIZING(runtime, ts));

if (!ts || !_Py_CURRENTLY_FINALIZING(runtime, ts)) {

return;

}

const PyConfig *config = &ts->interp->config;

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("cpython._PySys_ClearAuditHooks", NULL);

_PyErr_Clear(ts);

_Py_AuditHookEntry *e = _PyRuntime.audit_hook_head, *n;

_PyRuntime.audit_hook_head = NULL;

while (e) {

n = e->next;

PyMem_RawFree(e);

e = n;

}

}

int

PySys_AddAuditHook(Py_AuditHookFunction hook, void *userData)

{

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

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

/* Cannot invoke hooks until we are initialized */

if (runtime->initialized) {

if (PySys_Audit("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 = _PyRuntime.audit_hook_head;

if (!e) {

e = (_Py_AuditHookEntry*)PyMem_RawMalloc(sizeof(_Py_AuditHookEntry));

_PyRuntime.audit_hook_head = e;

} else {

while (e->next) {

e = e->next;

}

e = e->next = (_Py_AuditHookEntry*)PyMem_RawMalloc(

sizeof(_Py_AuditHookEntry));

}

if (!e) {

if (runtime->initialized) {

_PyErr_NoMemory(tstate);

}

return -1;

}

e->next = NULL;

e->hookCFunction = (Py_AuditHookFunction)hook;

e->userData = userData;

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("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 *is = tstate->interp;

if (is->audit_hooks == NULL) {

is->audit_hooks = PyList_New(0);

if (is->audit_hooks == NULL) {

return NULL;

}

}

if (PyList_Append(is->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();

if (argc == 0) {

_PyErr_SetString(tstate, PyExc_TypeError,

"audit() missing 1 required positional argument: "

"'event'");

return NULL;

}

if (!should_audit(tstate)) {

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(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(PyThreadState *tstate, 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_GetAttrId(outf, &PyId_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_LookupAttrId(outf, &PyId_buffer, &buffer) < 0) {

Py_DECREF(encoded);

goto error;

}

if (buffer) {

result = _PyObject_CallMethodIdOneArg(buffer, &PyId_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;

static PyObject *newline = NULL;

int err;

PyThreadState *tstate = _PyThreadState_GET();

builtins = _PyImport_GetModuleId(&PyId_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_SetAttrId(builtins, &PyId__, Py_None) != 0)

return NULL;

outf = sys_get_object_id(tstate, &PyId_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)) {

/* 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(tstate, outf, o);

if (err) {

return NULL;

}

}

else {

return NULL;

}

}

if (newline == NULL) {

newline = PyUnicode_FromString("\n");

if (newline == NULL)

return NULL;

}

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

return NULL;

if (_PyObject_SetAttrId(builtins, &PyId__, 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(exctype, value, traceback);

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 Py_BuildValue(

"(OOO)",

err_info->exc_type != NULL ? err_info->exc_type : Py_None,

err_info->exc_value != NULL ? err_info->exc_value : Py_None,

err_info->exc_traceback != NULL ?

err_info->exc_traceback : Py_None);

}

/*[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. */

PyThreadState *tstate = _PyThreadState_GET();

_PyErr_SetObject(tstate, PyExc_SystemExit, status);

return NULL;

}

/*[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 PyUnicode_FromString(PyUnicode_GetDefaultEncoding());

}

/*[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]*/

{

PyThreadState *tstate = _PyThreadState_GET();

const PyConfig *config = &tstate->interp->config;

return PyUnicode_FromWideChar(config->filesystem_encoding, -1);

}

/*[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]*/

{

PyThreadState *tstate = _PyThreadState_GET();

const PyConfig *config = &tstate->interp->config;

return PyUnicode_FromWideChar(config->filesystem_errors, -1);

}

/*[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]*/

{

PyThreadState *tstate = _PyThreadState_GET();

if (PyUnicode_CheckExact(s)) {

Py_INCREF(s);

PyUnicode_InternInPlace(&s);

return s;

}

else {

_PyErr_Format(tstate, PyExc_TypeError,

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

return NULL;

}

}

/*

* Cached interned string objects used for calling the profile and

* trace functions. Initialized by trace_init().

*/

static PyObject *whatstrings[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

static int

trace_init(void)

{

static const char * const whatnames[8] = {

"call", "exception", "line", "return",

"c_call", "c_exception", "c_return",

"opcode"

};

PyObject *name;

int i;

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

if (whatstrings[i] == NULL) {

name = PyUnicode_InternFromString(whatnames[i]);

if (name == NULL)

return -1;

whatstrings[i] = name;

}

}

return 0;

}

static PyObject *

call_trampoline(PyObject* callback,

PyFrameObject *frame, int what, PyObject *arg)

{

if (PyFrame_FastToLocalsWithError(frame) < 0) {

return NULL;

}

PyObject *stack[3];

stack[0] = (PyObject *)frame;

stack[1] = whatstrings[what];

stack[2] = (arg != NULL) ? arg : Py_None;

/* call the Python-level function */

PyObject *result = _PyObject_FastCall(callback, stack, 3);

PyFrame_LocalsToFast(frame, 1);

if (result == NULL) {

PyTraceBack_Here(frame);

}

return result;

}

static int

profile_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

PyObject *result;

if (arg == NULL)

arg = Py_None;

result = call_trampoline(self, frame, what, arg);

if (result == NULL) {

PyEval_SetProfile(NULL, NULL);

return -1;

}

Py_DECREF(result);

return 0;

}

static int

trace_trampoline(PyObject *self, PyFrameObject *frame,

int what, PyObject *arg)

{

PyObject *callback;

PyObject *result;

if (what == PyTrace_CALL)

callback = self;

else

callback = frame->f_trace;

if (callback == NULL)

return 0;

result = call_trampoline(callback, frame, what, arg);

if (result == NULL) {

PyEval_SetTrace(NULL, NULL);

Py_CLEAR(frame->f_trace);

return -1;

}

if (result != Py_None) {

Py_XSETREF(frame->f_trace, result);

}

else {

Py_DECREF(result);

}

return 0;

}

static PyObject *

sys_settrace(PyObject *self, PyObject *args)

{

if (trace_init() == -1)

return NULL;

if (args == Py_None)

PyEval_SetTrace(NULL, NULL);

else

PyEval_SetTrace(trace_trampoline, args);

Py_RETURN_NONE;

}

PyDoc_STRVAR(settrace_doc,

"settrace(function)\n\

\n\

Set the global debug tracing function. It will be called on each\n\

function call. See the debugger chapter in the library manual."

);

/*[clinic input]

sys.gettrace

Return the global debug tracing function set with sys.settrace.

See the debugger chapter in the library manual.

[clinic start generated code]*/

static PyObject *

sys_gettrace_impl(PyObject *module)

/*[clinic end generated code: output=e97e3a4d8c971b6e input=373b51bb2147f4d8]*/

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *temp = tstate->c_traceobj;

if (temp == NULL)

temp = Py_None;

Py_INCREF(temp);

return temp;

}

static PyObject *

sys_setprofile(PyObject *self, PyObject *args)

{

if (trace_init() == -1)

return NULL;

if (args == Py_None)

PyEval_SetProfile(NULL, NULL);

else

PyEval_SetProfile(profile_trampoline, args);

Py_RETURN_NONE;

}

PyDoc_STRVAR(setprofile_doc,

"setprofile(function)\n\

\n\