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

#include "pycore_pymem.h"

#include "pycore_pathconfig.h"

#include "pycore_pystate.h"

#include "pythread.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);

PyObject *

_PySys_GetObjectId(_Py_Identifier *key)

{

PyObject *sd = _PyInterpreterState_GET_UNSAFE()->sysdict;

if (sd == NULL) {

return NULL;

}

return _PyDict_GetItemId(sd, key);

}

PyObject *

PySys_GetObject(const char *name)

{

PyObject *sd = _PyInterpreterState_GET_UNSAFE()->sysdict;

if (sd == NULL) {

return NULL;

}

return PyDict_GetItemString(sd, name);

}

int

_PySys_SetObjectId(_Py_Identifier *key, PyObject *v)

{

PyObject *sd = _PyInterpreterState_GET_UNSAFE()->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_SetObject(const char *name, PyObject *v)

{

PyObject *sd = _PyInterpreterState_GET_UNSAFE()->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);

}

}

static PyObject *

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

{

assert(!PyErr_Occurred());

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();

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 {

/* Split on the last dot; */

modulepath = PyUnicode_FromStringAndSize(envar, last_dot - envar);

attrname = last_dot + 1;

}

if (modulepath == NULL) {

PyMem_RawFree(envar);

return NULL;

}

PyObject *module = PyImport_Import(modulepath);

Py_DECREF(modulepath);

if (module == NULL) {

goto error;

}

PyObject *hook = PyObject_GetAttrString(module, attrname);

Py_DECREF(module);

if (hook == NULL) {

goto error;

}

PyMem_RawFree(envar);

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

Py_DECREF(hook);

return retval;

error:

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

PyErr_Clear();

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

buffer = _PyObject_GetAttrId(outf, &PyId_buffer);

if (buffer) {

result = _PyObject_CallMethodIdObjArgs(buffer, &PyId_write, encoded, NULL);

Py_DECREF(buffer);

Py_DECREF(encoded);

if (result == NULL)

goto error;

Py_DECREF(result);

}

else {

PyErr_Clear();

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;

}

static PyObject *

sys_displayhook(PyObject *self, PyObject *o)

{

PyObject *outf;

PyObject *builtins;

static PyObject *newline = NULL;

int err;

builtins = _PyImport_GetModuleId(&PyId_builtins);

if (builtins == NULL) {

PyErr_SetString(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 = _PySys_GetObjectId(&PyId_stdout);

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

PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");

return NULL;

}

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

if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) {

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

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

PyErr_Clear();

err = sys_displayhook_unencodable(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;

}

PyDoc_STRVAR(displayhook_doc,

"displayhook(object) -> None\n"

"\n"

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

);

static PyObject *

sys_excepthook(PyObject* self, PyObject* args)

{

PyObject *exc, *value, *tb;

if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))

return NULL;

PyErr_Display(exc, value, tb);

Py_RETURN_NONE;

}

PyDoc_STRVAR(excepthook_doc,

"excepthook(exctype, value, traceback) -> None\n"

"\n"

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

);

static PyObject *

sys_exc_info(PyObject *self, PyObject *noargs)

{

_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);

}

PyDoc_STRVAR(exc_info_doc,

"exc_info() -> (type, value, traceback)\n\

\n\

Return information about the most recent exception caught by an except\n\

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

);

static PyObject *

sys_exit(PyObject *self, PyObject *args)

{

PyObject *exit_code = 0;

if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))

return NULL;

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

PyErr_SetObject(PyExc_SystemExit, exit_code);

return NULL;

}

PyDoc_STRVAR(exit_doc,

"exit([status])\n\

\n\

Exit the interpreter by raising SystemExit(status).\n\

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

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

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

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

);

static PyObject *

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

{

return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());

}

PyDoc_STRVAR(getdefaultencoding_doc,

"getdefaultencoding() -> string\n\

\n\

Return the current default string encoding used by the Unicode\n\

implementation."

);

static PyObject *

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

{

PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();

const _PyCoreConfig *config = &interp->core_config;

return PyUnicode_FromString(config->filesystem_encoding);

}

PyDoc_STRVAR(getfilesystemencoding_doc,

"getfilesystemencoding() -> string\n\

\n\

Return the encoding used to convert Unicode filenames in\n\

operating system filenames."

);

static PyObject *

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

{

PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();

const _PyCoreConfig *config = &interp->core_config;

return PyUnicode_FromString(config->filesystem_errors);

}

PyDoc_STRVAR(getfilesystemencodeerrors_doc,

"getfilesystemencodeerrors() -> string\n\

\n\

Return the error mode used to convert Unicode filenames in\n\

operating system filenames."

);

static PyObject *

sys_intern(PyObject *self, PyObject *args)

{

PyObject *s;

if (!PyArg_ParseTuple(args, "U:intern", &s))

return NULL;

if (PyUnicode_CheckExact(s)) {

Py_INCREF(s);

PyUnicode_InternInPlace(&s);

return s;

}

else {

PyErr_Format(PyExc_TypeError,

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

return NULL;

}

}

PyDoc_STRVAR(intern_doc,

"intern(string) -> string\n\

\n\

``Intern'' the given string. This enters the string in the (global)\n\

table of interned strings whose purpose is to speed up dictionary lookups.\n\

Return the string itself or the previously interned string object with the\n\

same value.");

/*

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

{

PyObject *result;

PyObject *stack[3];

if (PyFrame_FastToLocalsWithError(frame) < 0) {

return NULL;

}

stack[0] = (PyObject *)frame;

stack[1] = whatstrings[what];

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

/* call the Python-level function */

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."

);

static PyObject *

sys_gettrace(PyObject *self, PyObject *args)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *temp = tstate->c_traceobj;

if (temp == NULL)

temp = Py_None;

Py_INCREF(temp);

return temp;

}

PyDoc_STRVAR(gettrace_doc,

"gettrace()\n\

\n\

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

See the debugger chapter in the library manual."

);

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\

Set the profiling function. It will be called on each function call\n\

and return. See the profiler chapter in the library manual."

);

static PyObject *

sys_getprofile(PyObject *self, PyObject *args)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *temp = tstate->c_profileobj;

if (temp == NULL)

temp = Py_None;

Py_INCREF(temp);

return temp;

}

PyDoc_STRVAR(getprofile_doc,

"getprofile()\n\

\n\

Return the profiling function set with sys.setprofile.\n\

See the profiler chapter in the library manual."

);

static PyObject *

sys_setcheckinterval(PyObject *self, PyObject *args)

{

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"sys.getcheckinterval() and sys.setcheckinterval() "

"are deprecated. Use sys.setswitchinterval() "

"instead.", 1) < 0)

return NULL;

int check_interval;

if (!PyArg_ParseTuple(args, "i:setcheckinterval", &check_interval))

return NULL;

PyInterpreterState *interp = _PyInterpreterState_Get();

interp->check_interval = check_interval;

Py_RETURN_NONE;

}

PyDoc_STRVAR(setcheckinterval_doc,

"setcheckinterval(n)\n\

\n\

Tell the Python interpreter to check for asynchronous events every\n\

n instructions. This also affects how often thread switches occur."

);

static PyObject *

sys_getcheckinterval(PyObject *self, PyObject *args)

{

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"sys.getcheckinterval() and sys.setcheckinterval() "

"are deprecated. Use sys.getswitchinterval() "

"instead.", 1) < 0)

return NULL;

PyInterpreterState *interp = _PyInterpreterState_Get();

return PyLong_FromLong(interp->check_interval);

}

PyDoc_STRVAR(getcheckinterval_doc,

"getcheckinterval() -> current check interval; see setcheckinterval()."

);

static PyObject *

sys_setswitchinterval(PyObject *self, PyObject *args)

{

double d;

if (!PyArg_ParseTuple(args, "d:setswitchinterval", &d))

return NULL;

if (d <= 0.0) {

PyErr_SetString(PyExc_ValueError,

"switch interval must be strictly positive");

return NULL;

}

_PyEval_SetSwitchInterval((unsigned long) (1e6 * d));

Py_RETURN_NONE;

}

PyDoc_STRVAR(setswitchinterval_doc,

"setswitchinterval(n)\n\

\n\

Set the ideal thread switching delay inside the Python interpreter\n\

The actual frequency of switching threads can be lower if the\n\

interpreter executes long sequences of uninterruptible code\n\

(this is implementation-specific and workload-dependent).\n\

\n\

The parameter must represent the desired switching delay in seconds\n\

A typical value is 0.005 (5 milliseconds)."

);

static PyObject *

sys_getswitchinterval(PyObject *self, PyObject *args)

{

return PyFloat_FromDouble(1e-6 * _PyEval_GetSwitchInterval());

}

PyDoc_STRVAR(getswitchinterval_doc,

"getswitchinterval() -> current thread switch interval; see setswitchinterval()."

);

static PyObject *

sys_setrecursionlimit(PyObject *self, PyObject *args)

{

int new_limit, mark;

PyThreadState *tstate;

if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))

return NULL;

if (new_limit < 1) {

PyErr_SetString(PyExc_ValueError,

"recursion limit must be greater or equal than 1");

return NULL;

}

/* Issue #25274: When the recursion depth hits the recursion limit in

_Py_CheckRecursiveCall(), the overflowed flag of the thread state is

set to 1 and a RecursionError is raised. The overflowed flag is reset

to 0 when the recursion depth goes below the low-water mark: see

Py_LeaveRecursiveCall().

Reject too low new limit if the current recursion depth is higher than

the new low-water mark. Otherwise it may not be possible anymore to

reset the overflowed flag to 0. */

mark = _Py_RecursionLimitLowerWaterMark(new_limit);

tstate = _PyThreadState_GET();

if (tstate->recursion_depth >= mark) {

PyErr_Format(PyExc_RecursionError,

"cannot set the recursion limit to %i at "

"the recursion depth %i: the limit is too low",

new_limit, tstate->recursion_depth);

return NULL;

}

Py_SetRecursionLimit(new_limit);

Py_RETURN_NONE;

}

/*[clinic input]

sys.set_coroutine_origin_tracking_depth

depth: int

Enable or disable origin tracking for coroutine objects in this thread.

Coroutine objects will track 'depth' frames of traceback information about

where they came from, available in their cr_origin attribute. Set depth of 0

to disable.

[clinic start generated code]*/

static PyObject *

sys_set_coroutine_origin_tracking_depth_impl(PyObject *module, int depth)

/*[clinic end generated code: output=0a2123c1cc6759c5 input=9083112cccc1bdcb]*/

{

if (depth < 0) {

PyErr_SetString(PyExc_ValueError, "depth must be >= 0");

return NULL;

}

_PyEval_SetCoroutineOriginTrackingDepth(depth);

Py_RETURN_NONE;

}

/*[clinic input]

sys.get_coroutine_origin_tracking_depth -> int

Check status of origin tracking for coroutine objects in this thread.

[clinic start generated code]*/

static int

sys_get_coroutine_origin_tracking_depth_impl(PyObject *module)

/*[clinic end generated code: output=3699f7be95a3afb8 input=335266a71205b61a]*/

{

return _PyEval_GetCoroutineOriginTrackingDepth();

}

static PyObject *

sys_set_coroutine_wrapper(PyObject *self, PyObject *wrapper)

{

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"set_coroutine_wrapper is deprecated", 1) < 0) {

return NULL;

}

if (wrapper != Py_None) {

if (!PyCallable_Check(wrapper)) {

PyErr_Format(PyExc_TypeError,

"callable expected, got %.50s",

Py_TYPE(wrapper)->tp_name);

return NULL;

}

_PyEval_SetCoroutineWrapper(wrapper);

}

else {

_PyEval_SetCoroutineWrapper(NULL);

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(set_coroutine_wrapper_doc,

"set_coroutine_wrapper(wrapper)\n\

\n\

Set a wrapper for coroutine objects."

);

static PyObject *

sys_get_coroutine_wrapper(PyObject *self, PyObject *args)

{

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"get_coroutine_wrapper is deprecated", 1) < 0) {

return NULL;

}

PyObject *wrapper = _PyEval_GetCoroutineWrapper();

if (wrapper == NULL) {

wrapper = Py_None;

}

Py_INCREF(wrapper);

return wrapper;

}

PyDoc_STRVAR(get_coroutine_wrapper_doc,

"get_coroutine_wrapper()\n\

\n\

Return the wrapper for coroutine objects set by sys.set_coroutine_wrapper."

);

static PyTypeObject AsyncGenHooksType;

PyDoc_STRVAR(asyncgen_hooks_doc,

"asyncgen_hooks\n\

\n\

A struct sequence providing information about asynhronous\n\

generators hooks. The attributes are read only.");

static PyStructSequence_Field asyncgen_hooks_fields[] = {

{"firstiter", "Hook to intercept first iteration"},

{"finalizer", "Hook to intercept finalization"},

{0}

};

static PyStructSequence_Desc asyncgen_hooks_desc = {

"asyncgen_hooks", /* name */

asyncgen_hooks_doc, /* doc */

asyncgen_hooks_fields , /* fields */

2

};

static PyObject *

sys_set_asyncgen_hooks(PyObject *self, PyObject *args, PyObject *kw)

{

static char *keywords[] = {"firstiter", "finalizer", NULL};

PyObject *firstiter = NULL;

PyObject *finalizer = NULL;

if (!PyArg_ParseTupleAndKeywords(

args, kw, "|OO", keywords,

&firstiter, &finalizer)) {

return NULL;

}

if (finalizer && finalizer != Py_None) {

if (!PyCallable_Check(finalizer)) {

PyErr_Format(PyExc_TypeError,

"callable finalizer expected, got %.50s",

Py_TYPE(finalizer)->tp_name);

return NULL;

}

_PyEval_SetAsyncGenFinalizer(finalizer);

}

else if (finalizer == Py_None) {

_PyEval_SetAsyncGenFinalizer(NULL);

}

if (firstiter && firstiter != Py_None) {

if (!PyCallable_Check(firstiter)) {

PyErr_Format(PyExc_TypeError,

"callable firstiter expected, got %.50s",

Py_TYPE(firstiter)->tp_name);

return NULL;

}

_PyEval_SetAsyncGenFirstiter(firstiter);

}

else if (firstiter == Py_None) {

_PyEval_SetAsyncGenFirstiter(NULL);

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(set_asyncgen_hooks_doc,

"set_asyncgen_hooks(*, firstiter=None, finalizer=None)\n\

\n\

Set a finalizer for async generators objects."

);

static PyObject *

sys_get_asyncgen_hooks(PyObject *self, PyObject *args)

{

PyObject *res;

PyObject *firstiter = _PyEval_GetAsyncGenFirstiter();

PyObject *finalizer = _PyEval_GetAsyncGenFinalizer();

res = PyStructSequence_New(&AsyncGenHooksType);

if (res == NULL) {

return NULL;

}

if (firstiter == NULL) {

firstiter = Py_None;

}

if (finalizer == NULL) {

finalizer = Py_None;

}

Py_INCREF(firstiter);

PyStructSequence_SET_ITEM(res, 0, firstiter);

Py_INCREF(finalizer);

PyStructSequence_SET_ITEM(res, 1, finalizer);

return res;

}

PyDoc_STRVAR(get_asyncgen_hooks_doc,

"get_asyncgen_hooks()\n\

\n\

Return a namedtuple of installed asynchronous generators hooks \

(firstiter, finalizer)."

);

static PyTypeObject Hash_InfoType;

PyDoc_STRVAR(hash_info_doc,

"hash_info\n\

\n\

A struct sequence providing parameters used for computing\n\

hashes. The attributes are read only.");

static PyStructSequence_Field hash_info_fields[] = {

{"width", "width of the type used for hashing, in bits"},

{"modulus", "prime number giving the modulus on which the hash "

"function is based"},

{"inf", "value to be used for hash of a positive infinity"},

{"nan", "value to be used for hash of a nan"},

{"imag", "multiplier used for the imaginary part of a complex number"},

{"algorithm", "name of the algorithm for hashing of str, bytes and "

"memoryviews"},

{"hash_bits", "internal output size of hash algorithm"},

{"seed_bits", "seed size of hash algorithm"},

{"cutoff", "small string optimization cutoff"},

{NULL, NULL}

};

static PyStructSequence_Desc hash_info_desc = {

"sys.hash_info",

hash_info_doc,

hash_info_fields,

9,

};

static PyObject *

get_hash_info(void)

{

PyObject *hash_info;

int field = 0;

PyHash_FuncDef *hashfunc;

hash_info = PyStructSequence_New(&Hash_InfoType);

if (hash_info == NULL)

return NULL;

hashfunc = PyHash_GetFuncDef();

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(8*sizeof(Py_hash_t)));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromSsize_t(_PyHASH_MODULUS));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(_PyHASH_INF));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(_PyHASH_NAN));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(_PyHASH_IMAG));

PyStructSequence_SET_ITEM(hash_info, field++,

PyUnicode_FromString(hashfunc->name));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(hashfunc->hash_bits));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(hashfunc->seed_bits));

PyStructSequence_SET_ITEM(hash_info, field++,

PyLong_FromLong(Py_HASH_CUTOFF));

if (PyErr_Occurred()) {

Py_CLEAR(hash_info);

return NULL;

}

return hash_info;

}

PyDoc_STRVAR(setrecursionlimit_doc,

"setrecursionlimit(n)\n\

\n\

Set the maximum depth of the Python interpreter stack to n. This\n\

limit prevents infinite recursion from causing an overflow of the C\n\

stack and crashing Python. The highest possible limit is platform-\n\

dependent."

);