bpo-20182: AC convert Python/sysmodule.c (GH-11328)

1 files changed, 970 insertions, 4 deletions

diff --git a/Python/clinic/sysmodule.c.h b/Python/clinic/sysmodule.c.h
index f9415ae..2d9c6e2 100644
--- a/Python/clinic/sysmodule.c.h
+++ b/Python/clinic/sysmodule.c.h
@@ -2,15 +2,398 @@
 preserve
 [clinic start generated code]*/
 
+PyDoc_STRVAR(sys_displayhook__doc__,
+"displayhook($module, object, /)\n"
+"--\n"
+"\n"
+"Print an object to sys.stdout and also save it in builtins._");
+
+#define SYS_DISPLAYHOOK_METHODDEF    \
+    {"displayhook", (PyCFunction)sys_displayhook, METH_O, sys_displayhook__doc__},
+
+PyDoc_STRVAR(sys_excepthook__doc__,
+"excepthook($module, exctype, value, traceback, /)\n"
+"--\n"
+"\n"
+"Handle an exception by displaying it with a traceback on sys.stderr.");
+
+#define SYS_EXCEPTHOOK_METHODDEF    \
+    {"excepthook", (PyCFunction)(void(*)(void))sys_excepthook, METH_FASTCALL, sys_excepthook__doc__},
+
+static PyObject *
+sys_excepthook_impl(PyObject *module, PyObject *exctype, PyObject *value,
+                    PyObject *traceback);
+
+static PyObject *
+sys_excepthook(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *exctype;
+    PyObject *value;
+    PyObject *traceback;
+
+    if (!_PyArg_UnpackStack(args, nargs, "excepthook",
+        3, 3,
+        &exctype, &value, &traceback)) {
+        goto exit;
+    }
+    return_value = sys_excepthook_impl(module, exctype, value, traceback);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_exc_info__doc__,
+"exc_info($module, /)\n"
+"--\n"
+"\n"
+"Return current exception information: (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.");
+
+#define SYS_EXC_INFO_METHODDEF    \
+    {"exc_info", (PyCFunction)sys_exc_info, METH_NOARGS, sys_exc_info__doc__},
+
+static PyObject *
+sys_exc_info_impl(PyObject *module);
+
+static PyObject *
+sys_exc_info(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_exc_info_impl(module);
+}
+
+PyDoc_STRVAR(sys_exit__doc__,
+"exit($module, status=None, /)\n"
+"--\n"
+"\n"
+"Exit the interpreter by raising SystemExit(status).\n"
+"\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).");
+
+#define SYS_EXIT_METHODDEF    \
+    {"exit", (PyCFunction)(void(*)(void))sys_exit, METH_FASTCALL, sys_exit__doc__},
+
+static PyObject *
+sys_exit_impl(PyObject *module, PyObject *status);
+
+static PyObject *
+sys_exit(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *status = NULL;
+
+    if (!_PyArg_UnpackStack(args, nargs, "exit",
+        0, 1,
+        &status)) {
+        goto exit;
+    }
+    return_value = sys_exit_impl(module, status);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_getdefaultencoding__doc__,
+"getdefaultencoding($module, /)\n"
+"--\n"
+"\n"
+"Return the current default encoding used by the Unicode implementation.");
+
+#define SYS_GETDEFAULTENCODING_METHODDEF    \
+    {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, METH_NOARGS, sys_getdefaultencoding__doc__},
+
+static PyObject *
+sys_getdefaultencoding_impl(PyObject *module);
+
+static PyObject *
+sys_getdefaultencoding(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getdefaultencoding_impl(module);
+}
+
+PyDoc_STRVAR(sys_getfilesystemencoding__doc__,
+"getfilesystemencoding($module, /)\n"
+"--\n"
+"\n"
+"Return the encoding used to convert Unicode filenames to OS filenames.");
+
+#define SYS_GETFILESYSTEMENCODING_METHODDEF    \
+    {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, METH_NOARGS, sys_getfilesystemencoding__doc__},
+
+static PyObject *
+sys_getfilesystemencoding_impl(PyObject *module);
+
+static PyObject *
+sys_getfilesystemencoding(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getfilesystemencoding_impl(module);
+}
+
+PyDoc_STRVAR(sys_getfilesystemencodeerrors__doc__,
+"getfilesystemencodeerrors($module, /)\n"
+"--\n"
+"\n"
+"Return the error mode used Unicode to OS filename conversion.");
+
+#define SYS_GETFILESYSTEMENCODEERRORS_METHODDEF    \
+    {"getfilesystemencodeerrors", (PyCFunction)sys_getfilesystemencodeerrors, METH_NOARGS, sys_getfilesystemencodeerrors__doc__},
+
+static PyObject *
+sys_getfilesystemencodeerrors_impl(PyObject *module);
+
+static PyObject *
+sys_getfilesystemencodeerrors(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getfilesystemencodeerrors_impl(module);
+}
+
+PyDoc_STRVAR(sys_intern__doc__,
+"intern($module, string, /)\n"
+"--\n"
+"\n"
+"``Intern\'\' the given string.\n"
+"\n"
+"This enters the string in the (global) table of interned strings whose\n"
+"purpose is to speed up dictionary lookups. Return the string itself or\n"
+"the previously interned string object with the same value.");
+
+#define SYS_INTERN_METHODDEF    \
+    {"intern", (PyCFunction)sys_intern, METH_O, sys_intern__doc__},
+
+static PyObject *
+sys_intern_impl(PyObject *module, PyObject *s);
+
+static PyObject *
+sys_intern(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    PyObject *s;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("intern", "str", arg);
+        goto exit;
+    }
+    if (PyUnicode_READY(arg) == -1) {
+        goto exit;
+    }
+    s = arg;
+    return_value = sys_intern_impl(module, s);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_gettrace__doc__,
+"gettrace($module, /)\n"
+"--\n"
+"\n"
+"Return the global debug tracing function set with sys.settrace.\n"
+"\n"
+"See the debugger chapter in the library manual.");
+
+#define SYS_GETTRACE_METHODDEF    \
+    {"gettrace", (PyCFunction)sys_gettrace, METH_NOARGS, sys_gettrace__doc__},
+
+static PyObject *
+sys_gettrace_impl(PyObject *module);
+
+static PyObject *
+sys_gettrace(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_gettrace_impl(module);
+}
+
+PyDoc_STRVAR(sys_getprofile__doc__,
+"getprofile($module, /)\n"
+"--\n"
+"\n"
+"Return the profiling function set with sys.setprofile.\n"
+"\n"
+"See the profiler chapter in the library manual.");
+
+#define SYS_GETPROFILE_METHODDEF    \
+    {"getprofile", (PyCFunction)sys_getprofile, METH_NOARGS, sys_getprofile__doc__},
+
+static PyObject *
+sys_getprofile_impl(PyObject *module);
+
+static PyObject *
+sys_getprofile(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getprofile_impl(module);
+}
+
+PyDoc_STRVAR(sys_setcheckinterval__doc__,
+"setcheckinterval($module, n, /)\n"
+"--\n"
+"\n"
+"Set the async event check interval to n instructions.\n"
+"\n"
+"This tells the Python interpreter to check for asynchronous events\n"
+"every n instructions.\n"
+"\n"
+"This also affects how often thread switches occur.");
+
+#define SYS_SETCHECKINTERVAL_METHODDEF    \
+    {"setcheckinterval", (PyCFunction)sys_setcheckinterval, METH_O, sys_setcheckinterval__doc__},
+
+static PyObject *
+sys_setcheckinterval_impl(PyObject *module, int n);
+
+static PyObject *
+sys_setcheckinterval(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int n;
+
+    if (PyFloat_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float" );
+        goto exit;
+    }
+    n = _PyLong_AsInt(arg);
+    if (n == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = sys_setcheckinterval_impl(module, n);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_getcheckinterval__doc__,
+"getcheckinterval($module, /)\n"
+"--\n"
+"\n"
+"Return the current check interval; see sys.setcheckinterval().");
+
+#define SYS_GETCHECKINTERVAL_METHODDEF    \
+    {"getcheckinterval", (PyCFunction)sys_getcheckinterval, METH_NOARGS, sys_getcheckinterval__doc__},
+
+static PyObject *
+sys_getcheckinterval_impl(PyObject *module);
+
+static PyObject *
+sys_getcheckinterval(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getcheckinterval_impl(module);
+}
+
+PyDoc_STRVAR(sys_setswitchinterval__doc__,
+"setswitchinterval($module, interval, /)\n"
+"--\n"
+"\n"
+"Set the ideal thread switching delay inside the Python interpreter.\n"
+"\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).");
+
+#define SYS_SETSWITCHINTERVAL_METHODDEF    \
+    {"setswitchinterval", (PyCFunction)sys_setswitchinterval, METH_O, sys_setswitchinterval__doc__},
+
+static PyObject *
+sys_setswitchinterval_impl(PyObject *module, double interval);
+
+static PyObject *
+sys_setswitchinterval(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    double interval;
+
+    interval = PyFloat_AsDouble(arg);
+    if (PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = sys_setswitchinterval_impl(module, interval);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_getswitchinterval__doc__,
+"getswitchinterval($module, /)\n"
+"--\n"
+"\n"
+"Return the current thread switch interval; see sys.setswitchinterval().");
+
+#define SYS_GETSWITCHINTERVAL_METHODDEF    \
+    {"getswitchinterval", (PyCFunction)sys_getswitchinterval, METH_NOARGS, sys_getswitchinterval__doc__},
+
+static double
+sys_getswitchinterval_impl(PyObject *module);
+
+static PyObject *
+sys_getswitchinterval(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+    double _return_value;
+
+    _return_value = sys_getswitchinterval_impl(module);
+    if ((_return_value == -1.0) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyFloat_FromDouble(_return_value);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_setrecursionlimit__doc__,
+"setrecursionlimit($module, limit, /)\n"
+"--\n"
+"\n"
+"Set the maximum depth of the Python interpreter stack to n.\n"
+"\n"
+"This limit prevents infinite recursion from causing an overflow of the C\n"
+"stack and crashing Python.  The highest possible limit is platform-\n"
+"dependent.");
+
+#define SYS_SETRECURSIONLIMIT_METHODDEF    \
+    {"setrecursionlimit", (PyCFunction)sys_setrecursionlimit, METH_O, sys_setrecursionlimit__doc__},
+
+static PyObject *
+sys_setrecursionlimit_impl(PyObject *module, int new_limit);
+
+static PyObject *
+sys_setrecursionlimit(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int new_limit;
+
+    if (PyFloat_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float" );
+        goto exit;
+    }
+    new_limit = _PyLong_AsInt(arg);
+    if (new_limit == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = sys_setrecursionlimit_impl(module, new_limit);
+
+exit:
+    return return_value;
+}
+
 PyDoc_STRVAR(sys_set_coroutine_origin_tracking_depth__doc__,
 "set_coroutine_origin_tracking_depth($module, /, depth)\n"
 "--\n"
 "\n"
 "Enable or disable origin tracking for coroutine objects in this thread.\n"
 "\n"
-"Coroutine objects will track \'depth\' frames of traceback information about\n"
-"where they came from, available in their cr_origin attribute. Set depth of 0\n"
-"to disable.");
+"Coroutine objects will track \'depth\' frames of traceback information\n"
+"about where they came from, available in their cr_origin attribute.\n"
+"\n"
+"Set a depth of 0 to disable.");
 
 #define SYS_SET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF    \
     {"set_coroutine_origin_tracking_depth", (PyCFunction)(void(*)(void))sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},
@@ -63,4 +446,587 @@ sys_get_coroutine_origin_tracking_depth(PyObject *module, PyObject *Py_UNUSED(ig
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=dfd3eb5b137a9861 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(sys_set_coroutine_wrapper__doc__,
+"set_coroutine_wrapper($module, wrapper, /)\n"
+"--\n"
+"\n"
+"Set a wrapper for coroutine objects.");
+
+#define SYS_SET_COROUTINE_WRAPPER_METHODDEF    \
+    {"set_coroutine_wrapper", (PyCFunction)sys_set_coroutine_wrapper, METH_O, sys_set_coroutine_wrapper__doc__},
+
+PyDoc_STRVAR(sys_get_coroutine_wrapper__doc__,
+"get_coroutine_wrapper($module, /)\n"
+"--\n"
+"\n"
+"Return the wrapper for coroutines set by sys.set_coroutine_wrapper.");
+
+#define SYS_GET_COROUTINE_WRAPPER_METHODDEF    \
+    {"get_coroutine_wrapper", (PyCFunction)sys_get_coroutine_wrapper, METH_NOARGS, sys_get_coroutine_wrapper__doc__},
+
+static PyObject *
+sys_get_coroutine_wrapper_impl(PyObject *module);
+
+static PyObject *
+sys_get_coroutine_wrapper(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_get_coroutine_wrapper_impl(module);
+}
+
+PyDoc_STRVAR(sys_get_asyncgen_hooks__doc__,
+"get_asyncgen_hooks($module, /)\n"
+"--\n"
+"\n"
+"Return the installed asynchronous generators hooks.\n"
+"\n"
+"This returns a namedtuple of the form (firstiter, finalizer).");
+
+#define SYS_GET_ASYNCGEN_HOOKS_METHODDEF    \
+    {"get_asyncgen_hooks", (PyCFunction)sys_get_asyncgen_hooks, METH_NOARGS, sys_get_asyncgen_hooks__doc__},
+
+static PyObject *
+sys_get_asyncgen_hooks_impl(PyObject *module);
+
+static PyObject *
+sys_get_asyncgen_hooks(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_get_asyncgen_hooks_impl(module);
+}
+
+PyDoc_STRVAR(sys_getrecursionlimit__doc__,
+"getrecursionlimit($module, /)\n"
+"--\n"
+"\n"
+"Return the current value of the recursion limit.\n"
+"\n"
+"The recursion limit is the maximum depth of the Python interpreter\n"
+"stack.  This limit prevents infinite recursion from causing an overflow\n"
+"of the C stack and crashing Python.");
+
+#define SYS_GETRECURSIONLIMIT_METHODDEF    \
+    {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, sys_getrecursionlimit__doc__},
+
+static PyObject *
+sys_getrecursionlimit_impl(PyObject *module);
+
+static PyObject *
+sys_getrecursionlimit(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getrecursionlimit_impl(module);
+}
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(sys_getwindowsversion__doc__,
+"getwindowsversion($module, /)\n"
+"--\n"
+"\n"
+"Return info about the running version of Windows as a named tuple.\n"
+"\n"
+"The members are named: major, minor, build, platform, service_pack,\n"
+"service_pack_major, service_pack_minor, suite_mask, product_type and\n"
+"platform_version. For backward compatibility, only the first 5 items\n"
+"are available by indexing. All elements are numbers, except\n"
+"service_pack and platform_type which are strings, and platform_version\n"
+"which is a 3-tuple. Platform is always 2. Product_type may be 1 for a\n"
+"workstation, 2 for a domain controller, 3 for a server.\n"
+"Platform_version is a 3-tuple containing a version number that is\n"
+"intended for identifying the OS rather than feature detection.");
+
+#define SYS_GETWINDOWSVERSION_METHODDEF    \
+    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, sys_getwindowsversion__doc__},
+
+static PyObject *
+sys_getwindowsversion_impl(PyObject *module);
+
+static PyObject *
+sys_getwindowsversion(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getwindowsversion_impl(module);
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(sys__enablelegacywindowsfsencoding__doc__,
+"_enablelegacywindowsfsencoding($module, /)\n"
+"--\n"
+"\n"
+"Changes the default filesystem encoding to mbcs:replace.\n"
+"\n"
+"This is done for consistency with earlier versions of Python. See PEP\n"
+"529 for more information.\n"
+"\n"
+"This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING\n"
+"environment variable before launching Python.");
+
+#define SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF    \
+    {"_enablelegacywindowsfsencoding", (PyCFunction)sys__enablelegacywindowsfsencoding, METH_NOARGS, sys__enablelegacywindowsfsencoding__doc__},
+
+static PyObject *
+sys__enablelegacywindowsfsencoding_impl(PyObject *module);
+
+static PyObject *
+sys__enablelegacywindowsfsencoding(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys__enablelegacywindowsfsencoding_impl(module);
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if defined(HAVE_DLOPEN)
+
+PyDoc_STRVAR(sys_setdlopenflags__doc__,
+"setdlopenflags($module, flags, /)\n"
+"--\n"
+"\n"
+"Set the flags used by the interpreter for dlopen calls.\n"
+"\n"
+"This is used, for example, when the interpreter loads extension\n"
+"modules. Among other things, this will enable a lazy resolving of\n"
+"symbols when importing a module, if called as sys.setdlopenflags(0).\n"
+"To share symbols across extension modules, call as\n"
+"sys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag\n"
+"modules can be found in the os module (RTLD_xxx constants, e.g.\n"
+"os.RTLD_LAZY).");
+
+#define SYS_SETDLOPENFLAGS_METHODDEF    \
+    {"setdlopenflags", (PyCFunction)sys_setdlopenflags, METH_O, sys_setdlopenflags__doc__},
+
+static PyObject *
+sys_setdlopenflags_impl(PyObject *module, int new_val);
+
+static PyObject *
+sys_setdlopenflags(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int new_val;
+
+    if (PyFloat_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float" );
+        goto exit;
+    }
+    new_val = _PyLong_AsInt(arg);
+    if (new_val == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = sys_setdlopenflags_impl(module, new_val);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_DLOPEN) */
+
+#if defined(HAVE_DLOPEN)
+
+PyDoc_STRVAR(sys_getdlopenflags__doc__,
+"getdlopenflags($module, /)\n"
+"--\n"
+"\n"
+"Return the current value of the flags that are used for dlopen calls.\n"
+"\n"
+"The flag constants are defined in the os module.");
+
+#define SYS_GETDLOPENFLAGS_METHODDEF    \
+    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, sys_getdlopenflags__doc__},
+
+static PyObject *
+sys_getdlopenflags_impl(PyObject *module);
+
+static PyObject *
+sys_getdlopenflags(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getdlopenflags_impl(module);
+}
+
+#endif /* defined(HAVE_DLOPEN) */
+
+#if defined(USE_MALLOPT)
+
+PyDoc_STRVAR(sys_mdebug__doc__,
+"mdebug($module, flag, /)\n"
+"--\n"
+"\n");
+
+#define SYS_MDEBUG_METHODDEF    \
+    {"mdebug", (PyCFunction)sys_mdebug, METH_O, sys_mdebug__doc__},
+
+static PyObject *
+sys_mdebug_impl(PyObject *module, int flag);
+
+static PyObject *
+sys_mdebug(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    int flag;
+
+    if (PyFloat_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float" );
+        goto exit;
+    }
+    flag = _PyLong_AsInt(arg);
+    if (flag == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = sys_mdebug_impl(module, flag);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(USE_MALLOPT) */
+
+PyDoc_STRVAR(sys_getrefcount__doc__,
+"getrefcount($module, object, /)\n"
+"--\n"
+"\n"
+"Return the reference count of object.\n"
+"\n"
+"The count returned is generally one higher than you might expect,\n"
+"because it includes the (temporary) reference as an argument to\n"
+"getrefcount().");
+
+#define SYS_GETREFCOUNT_METHODDEF    \
+    {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, sys_getrefcount__doc__},
+
+static Py_ssize_t
+sys_getrefcount_impl(PyObject *module, PyObject *object);
+
+static PyObject *
+sys_getrefcount(PyObject *module, PyObject *object)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t _return_value;
+
+    _return_value = sys_getrefcount_impl(module, object);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+#if defined(Py_REF_DEBUG)
+
+PyDoc_STRVAR(sys_gettotalrefcount__doc__,
+"gettotalrefcount($module, /)\n"
+"--\n"
+"\n");
+
+#define SYS_GETTOTALREFCOUNT_METHODDEF    \
+    {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS, sys_gettotalrefcount__doc__},
+
+static Py_ssize_t
+sys_gettotalrefcount_impl(PyObject *module);
+
+static PyObject *
+sys_gettotalrefcount(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t _return_value;
+
+    _return_value = sys_gettotalrefcount_impl(module);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(Py_REF_DEBUG) */
+
+PyDoc_STRVAR(sys_getallocatedblocks__doc__,
+"getallocatedblocks($module, /)\n"
+"--\n"
+"\n"
+"Return the number of memory blocks currently allocated.");
+
+#define SYS_GETALLOCATEDBLOCKS_METHODDEF    \
+    {"getallocatedblocks", (PyCFunction)sys_getallocatedblocks, METH_NOARGS, sys_getallocatedblocks__doc__},
+
+static Py_ssize_t
+sys_getallocatedblocks_impl(PyObject *module);
+
+static PyObject *
+sys_getallocatedblocks(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t _return_value;
+
+    _return_value = sys_getallocatedblocks_impl(module);
+    if ((_return_value == -1) && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+#if defined(COUNT_ALLOCS)
+
+PyDoc_STRVAR(sys_getcounts__doc__,
+"getcounts($module, /)\n"
+"--\n"
+"\n");
+
+#define SYS_GETCOUNTS_METHODDEF    \
+    {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS, sys_getcounts__doc__},
+
+static PyObject *
+sys_getcounts_impl(PyObject *module);
+
+static PyObject *
+sys_getcounts(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getcounts_impl(module);
+}
+
+#endif /* defined(COUNT_ALLOCS) */
+
+PyDoc_STRVAR(sys__getframe__doc__,
+"_getframe($module, depth=0, /)\n"
+"--\n"
+"\n"
+"Return a frame object from the call stack.\n"
+"\n"
+"If optional integer depth is given, return the frame object that many\n"
+"calls below the top of the stack.  If that is deeper than the call\n"
+"stack, ValueError is raised.  The default for depth is zero, returning\n"
+"the frame at the top of the call stack.\n"
+"\n"
+"This function should be used for internal and specialized purposes\n"
+"only.");
+
+#define SYS__GETFRAME_METHODDEF    \
+    {"_getframe", (PyCFunction)(void(*)(void))sys__getframe, METH_FASTCALL, sys__getframe__doc__},
+
+static PyObject *
+sys__getframe_impl(PyObject *module, int depth);
+
+static PyObject *
+sys__getframe(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    int depth = 0;
+
+    if (!_PyArg_ParseStack(args, nargs, "|i:_getframe",
+        &depth)) {
+        goto exit;
+    }
+    return_value = sys__getframe_impl(module, depth);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys__current_frames__doc__,
+"_current_frames($module, /)\n"
+"--\n"
+"\n"
+"Return a dict mapping each thread\'s thread id to its current stack frame.\n"
+"\n"
+"This function should be used for specialized purposes only.");
+
+#define SYS__CURRENT_FRAMES_METHODDEF    \
+    {"_current_frames", (PyCFunction)sys__current_frames, METH_NOARGS, sys__current_frames__doc__},
+
+static PyObject *
+sys__current_frames_impl(PyObject *module);
+
+static PyObject *
+sys__current_frames(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys__current_frames_impl(module);
+}
+
+PyDoc_STRVAR(sys_call_tracing__doc__,
+"call_tracing($module, func, args, /)\n"
+"--\n"
+"\n"
+"Call func(*args), while tracing is enabled.\n"
+"\n"
+"The tracing state is saved, and restored afterwards.  This is intended\n"
+"to be called from a debugger from a checkpoint, to recursively debug\n"
+"some other code.");
+
+#define SYS_CALL_TRACING_METHODDEF    \
+    {"call_tracing", (PyCFunction)(void(*)(void))sys_call_tracing, METH_FASTCALL, sys_call_tracing__doc__},
+
+static PyObject *
+sys_call_tracing_impl(PyObject *module, PyObject *func, PyObject *funcargs);
+
+static PyObject *
+sys_call_tracing(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *func;
+    PyObject *funcargs;
+
+    if (!_PyArg_ParseStack(args, nargs, "OO!:call_tracing",
+        &func, &PyTuple_Type, &funcargs)) {
+        goto exit;
+    }
+    return_value = sys_call_tracing_impl(module, func, funcargs);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(sys_callstats__doc__,
+"callstats($module, /)\n"
+"--\n"
+"\n"
+"Return a tuple of function call statistics.\n"
+"\n"
+"A tuple is returned only if CALL_PROFILE was defined when Python was\n"
+"built.  Otherwise, this returns None.\n"
+"\n"
+"When enabled, this function returns detailed, implementation-specific\n"
+"details about the number of function calls executed. The return value\n"
+"is a 11-tuple where the entries in the tuple are counts of:\n"
+"0. all function calls\n"
+"1. calls to PyFunction_Type objects\n"
+"2. PyFunction calls that do not create an argument tuple\n"
+"3. PyFunction calls that do not create an argument tuple\n"
+"   and bypass PyEval_EvalCodeEx()\n"
+"4. PyMethod calls\n"
+"5. PyMethod calls on bound methods\n"
+"6. PyType calls\n"
+"7. PyCFunction calls\n"
+"8. generator calls\n"
+"9. All other calls\n"
+"10. Number of stack pops performed by call_function()");
+
+#define SYS_CALLSTATS_METHODDEF    \
+    {"callstats", (PyCFunction)sys_callstats, METH_NOARGS, sys_callstats__doc__},
+
+static PyObject *
+sys_callstats_impl(PyObject *module);
+
+static PyObject *
+sys_callstats(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_callstats_impl(module);
+}
+
+PyDoc_STRVAR(sys__debugmallocstats__doc__,
+"_debugmallocstats($module, /)\n"
+"--\n"
+"\n"
+"Print summary info to stderr about the state of pymalloc\'s structures.\n"
+"\n"
+"In Py_DEBUG mode, also perform some expensive internal consistency\n"
+"checks.");
+
+#define SYS__DEBUGMALLOCSTATS_METHODDEF    \
+    {"_debugmallocstats", (PyCFunction)sys__debugmallocstats, METH_NOARGS, sys__debugmallocstats__doc__},
+
+static PyObject *
+sys__debugmallocstats_impl(PyObject *module);
+
+static PyObject *
+sys__debugmallocstats(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys__debugmallocstats_impl(module);
+}
+
+PyDoc_STRVAR(sys__clear_type_cache__doc__,
+"_clear_type_cache($module, /)\n"
+"--\n"
+"\n"
+"Clear the internal type lookup cache.");
+
+#define SYS__CLEAR_TYPE_CACHE_METHODDEF    \
+    {"_clear_type_cache", (PyCFunction)sys__clear_type_cache, METH_NOARGS, sys__clear_type_cache__doc__},
+
+static PyObject *
+sys__clear_type_cache_impl(PyObject *module);
+
+static PyObject *
+sys__clear_type_cache(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys__clear_type_cache_impl(module);
+}
+
+PyDoc_STRVAR(sys_is_finalizing__doc__,
+"is_finalizing($module, /)\n"
+"--\n"
+"\n"
+"Return True if Python is exiting.");
+
+#define SYS_IS_FINALIZING_METHODDEF    \
+    {"is_finalizing", (PyCFunction)sys_is_finalizing, METH_NOARGS, sys_is_finalizing__doc__},
+
+static PyObject *
+sys_is_finalizing_impl(PyObject *module);
+
+static PyObject *
+sys_is_finalizing(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_is_finalizing_impl(module);
+}
+
+#if defined(ANDROID_API_LEVEL)
+
+PyDoc_STRVAR(sys_getandroidapilevel__doc__,
+"getandroidapilevel($module, /)\n"
+"--\n"
+"\n"
+"Return the build time API version of Android as an integer.");
+
+#define SYS_GETANDROIDAPILEVEL_METHODDEF    \
+    {"getandroidapilevel", (PyCFunction)sys_getandroidapilevel, METH_NOARGS, sys_getandroidapilevel__doc__},
+
+static PyObject *
+sys_getandroidapilevel_impl(PyObject *module);
+
+static PyObject *
+sys_getandroidapilevel(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+    return sys_getandroidapilevel_impl(module);
+}
+
+#endif /* defined(ANDROID_API_LEVEL) */
+
+#ifndef SYS_GETWINDOWSVERSION_METHODDEF
+    #define SYS_GETWINDOWSVERSION_METHODDEF
+#endif /* !defined(SYS_GETWINDOWSVERSION_METHODDEF) */
+
+#ifndef SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF
+    #define SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF
+#endif /* !defined(SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF) */
+
+#ifndef SYS_SETDLOPENFLAGS_METHODDEF
+    #define SYS_SETDLOPENFLAGS_METHODDEF
+#endif /* !defined(SYS_SETDLOPENFLAGS_METHODDEF) */
+
+#ifndef SYS_GETDLOPENFLAGS_METHODDEF
+    #define SYS_GETDLOPENFLAGS_METHODDEF
+#endif /* !defined(SYS_GETDLOPENFLAGS_METHODDEF) */
+
+#ifndef SYS_MDEBUG_METHODDEF
+    #define SYS_MDEBUG_METHODDEF
+#endif /* !defined(SYS_MDEBUG_METHODDEF) */
+
+#ifndef SYS_GETTOTALREFCOUNT_METHODDEF
+    #define SYS_GETTOTALREFCOUNT_METHODDEF
+#endif /* !defined(SYS_GETTOTALREFCOUNT_METHODDEF) */
+
+#ifndef SYS_GETCOUNTS_METHODDEF
+    #define SYS_GETCOUNTS_METHODDEF
+#endif /* !defined(SYS_GETCOUNTS_METHODDEF) */
+
+#ifndef SYS_GETANDROIDAPILEVEL_METHODDEF
+    #define SYS_GETANDROIDAPILEVEL_METHODDEF
+#endif /* !defined(SYS_GETANDROIDAPILEVEL_METHODDEF) */
+/*[clinic end generated code: output=0e662f2e19293d57 input=a9049054013a1b77]*/