#include "Python.h"

#include "internal/pystate.h"

#include "code.h"

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

extern const char *PyWin_DLLVersionString;

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

{

PyThreadState *tstate = PyThreadState_GET();

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

if (sd == NULL)

return NULL;

return _PyDict_GetItemId(sd, 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);

}

_PySys_SetObjectId(_Py_Identifier *key, PyObject *v)

{

PyThreadState *tstate = PyThreadState_GET();

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

}

PySys_SetObject(const char *name, PyObject *v)

{

PyThreadState *tstate = PyThreadState_GET();

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

}

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

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 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 *fromlist = Py_BuildValue("(s)", attrname);

if (fromlist == NULL) {

Py_DECREF(modulepath);

PyMem_RawFree(envar);

return NULL;

}

PyObject *module = PyImport_ImportModuleLevelObject(

modulepath, NULL, NULL, fromlist, 0);

Py_DECREF(modulepath);

Py_DECREF(fromlist);

if (module == NULL) {

if (PyErr_ExceptionMatches(PyExc_ImportError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyObject *hook = PyObject_GetAttrString(module, attrname);

Py_DECREF(module);

if (hook == NULL) {

if (PyErr_ExceptionMatches(PyExc_AttributeError)) {

goto warn;

}

PyMem_RawFree(envar);

return NULL;

}

PyMem_RawFree(envar);

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

Py_DECREF(hook);

return retval;

warn:

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

);

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

if (!PyErr_Occurred()) {

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

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,

);

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,

);

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,

);

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,

);

static PyObject *

sys_getdefaultencoding(PyObject *self)

{

return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());

}

PyDoc_STRVAR(getdefaultencoding_doc,

);

static PyObject *

sys_getfilesystemencoding(PyObject *self)

{

if (Py_FileSystemDefaultEncoding)

return PyUnicode_FromString(Py_FileSystemDefaultEncoding);

PyErr_SetString(PyExc_RuntimeError,

"filesystem encoding is not initialized");

return NULL;

}

PyDoc_STRVAR(getfilesystemencoding_doc,

);

static PyObject *

sys_getfilesystemencodeerrors(PyObject *self)

{

if (Py_FileSystemDefaultEncodeErrors)

return PyUnicode_FromString(Py_FileSystemDefaultEncodeErrors);

PyErr_SetString(PyExc_RuntimeError,

"filesystem encoding is not initialized");

return NULL;

}

PyDoc_STRVAR(getfilesystemencodeerrors_doc,

"getfilesystemencodeerrors() -> string\n\

);

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,

same value.");

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,

);

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,

);

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,

);

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,

);

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;

PyInterpreterState *interp = PyThreadState_GET()->interp;

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

return NULL;

Py_RETURN_NONE;

}

PyDoc_STRVAR(setcheckinterval_doc,

);

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 = PyThreadState_GET()->interp;

return PyLong_FromLong(interp->check_interval);

}

PyDoc_STRVAR(getcheckinterval_doc,

);

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,

);

static PyObject *

sys_getswitchinterval(PyObject *self, PyObject *args)

{

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

}

PyDoc_STRVAR(getswitchinterval_doc,

);

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

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;

}

static PyObject *

sys_set_coroutine_origin_tracking_depth_impl(PyObject *module, int depth)

{

if (depth < 0) {

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

return NULL;

}

_PyEval_SetCoroutineOriginTrackingDepth(depth);

Py_RETURN_NONE;

}

static int

sys_get_coroutine_origin_tracking_depth_impl(PyObject *module)

{

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,

);

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,

);

static PyTypeObject AsyncGenHooksType;

PyDoc_STRVAR(asyncgen_hooks_doc,

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,

);

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,

);

static PyTypeObject Hash_InfoType;

PyDoc_STRVAR(hash_info_doc,

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