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

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

Python/sysmodule.c

@@ -252,8 +252,18 @@ finally:
     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 *self, PyObject *o)
+sys_displayhook(PyObject *module, PyObject *o)
+/*[clinic end generated code: output=347477d006df92ed input=08ba730166d7ef72]*/
 {
     PyObject *outf;
     PyObject *builtins;
@@ -305,30 +315,40 @@ sys_displayhook(PyObject *self, PyObject *o)
     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"
-);
+
+/*[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(PyObject* self, PyObject* args)
+sys_excepthook_impl(PyObject *module, PyObject *exctype, PyObject *value,
+                    PyObject *traceback)
+/*[clinic end generated code: output=18d99fdda21b6b5e input=ecf606fa826f19d9]*/
 {
-    PyObject *exc, *value, *tb;
-    if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
-        return NULL;
-    PyErr_Display(exc, value, tb);
+    PyErr_Display(exctype, value, traceback);
     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"
-);
+
+/*[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(PyObject *self, PyObject *noargs)
+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(
@@ -339,84 +359,92 @@ sys_exc_info(PyObject *self, PyObject *noargs)
             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."
-);
+
+/*[clinic input]
+sys.exit
+
+    status: object = NULL
+    /
+
+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(PyObject *self, PyObject *args)
+sys_exit_impl(PyObject *module, PyObject *status)
+/*[clinic end generated code: output=13870986c1ab2ec0 input=a737351f86685e9c]*/
 {
-    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);
+    PyErr_SetObject(PyExc_SystemExit, status);
     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)."
-);
 
 
+/*[clinic input]
+sys.getdefaultencoding
+
+Return the current default encoding used by the Unicode implementation.
+[clinic start generated code]*/
+
 static PyObject *
-sys_getdefaultencoding(PyObject *self, PyObject *Py_UNUSED(ignored))
+sys_getdefaultencoding_impl(PyObject *module)
+/*[clinic end generated code: output=256d19dfcc0711e6 input=d416856ddbef6909]*/
 {
     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."
-);
+/*[clinic input]
+sys.getfilesystemencoding
+
+Return the encoding used to convert Unicode filenames to OS filenames.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getfilesystemencoding(PyObject *self, PyObject *Py_UNUSED(ignored))
+sys_getfilesystemencoding_impl(PyObject *module)
+/*[clinic end generated code: output=1dc4bdbe9be44aa7 input=8475f8649b8c7d8c]*/
 {
     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."
-);
+/*[clinic input]
+sys.getfilesystemencodeerrors
+
+Return the error mode used Unicode to OS filename conversion.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getfilesystemencodeerrors(PyObject *self, PyObject *Py_UNUSED(ignored))
+sys_getfilesystemencodeerrors_impl(PyObject *module)
+/*[clinic end generated code: output=ba77b36bbf7c96f5 input=22a1e8365566f1e5]*/
 {
     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."
-);
+/*[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(PyObject *self, PyObject *args)
+sys_intern_impl(PyObject *module, PyObject *s)
+/*[clinic end generated code: output=be680c24f5c9e5d6 input=849483c006924e2f]*/
 {
-    PyObject *s;
-    if (!PyArg_ParseTuple(args, "U:intern", &s))
-        return NULL;
     if (PyUnicode_CheckExact(s)) {
         Py_INCREF(s);
         PyUnicode_InternInPlace(&s);
@@ -429,14 +457,6 @@ sys_intern(PyObject *self, PyObject *args)
     }
 }
 
-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
@@ -556,8 +576,17 @@ 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(PyObject *self, PyObject *args)
+sys_gettrace_impl(PyObject *module)
+/*[clinic end generated code: output=e97e3a4d8c971b6e input=373b51bb2147f4d8]*/
 {
     PyThreadState *tstate = _PyThreadState_GET();
     PyObject *temp = tstate->c_traceobj;
@@ -568,13 +597,6 @@ sys_gettrace(PyObject *self, PyObject *args)
     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)
 {
@@ -594,8 +616,17 @@ Set the profiling function.  It will be called on each function call\n\
 and return.  See the profiler chapter in the library manual."
 );
 
+/*[clinic input]
+sys.getprofile
+
+Return the profiling function set with sys.setprofile.
+
+See the profiler chapter in the library manual.
+[clinic start generated code]*/
+
 static PyObject *
-sys_getprofile(PyObject *self, PyObject *args)
+sys_getprofile_impl(PyObject *module)
+/*[clinic end generated code: output=579b96b373448188 input=1b3209d89a32965d]*/
 {
     PyThreadState *tstate = _PyThreadState_GET();
     PyObject *temp = tstate->c_profileobj;
@@ -606,15 +637,23 @@ sys_getprofile(PyObject *self, PyObject *args)
     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."
-);
+/*[clinic input]
+sys.setcheckinterval
+
+    n: int
+    /
+
+Set the async event check interval to n instructions.
+
+This tells the Python interpreter to check for asynchronous events
+every n instructions.
+
+This also affects how often thread switches occur.
+[clinic start generated code]*/
 
 static PyObject *
-sys_setcheckinterval(PyObject *self, PyObject *args)
+sys_setcheckinterval_impl(PyObject *module, int n)
+/*[clinic end generated code: output=3f686cef07e6e178 input=7a35b17bf22a6227]*/
 {
     if (PyErr_WarnEx(PyExc_DeprecationWarning,
                      "sys.getcheckinterval() and sys.setcheckinterval() "
@@ -622,24 +661,20 @@ sys_setcheckinterval(PyObject *self, PyObject *args)
                      "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;
+    interp->check_interval = n;
     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."
-);
+/*[clinic input]
+sys.getcheckinterval
+
+Return the current check interval; see sys.setcheckinterval().
+[clinic start generated code]*/
 
 static PyObject *
-sys_getcheckinterval(PyObject *self, PyObject *args)
+sys_getcheckinterval_impl(PyObject *module)
+/*[clinic end generated code: output=1b5060bf2b23a47c input=4b6589cbcca1db4e]*/
 {
     if (PyErr_WarnEx(PyExc_DeprecationWarning,
                      "sys.getcheckinterval() and sys.setcheckinterval() "
@@ -650,56 +685,69 @@ sys_getcheckinterval(PyObject *self, PyObject *args)
     return PyLong_FromLong(interp->check_interval);
 }
 
-PyDoc_STRVAR(getcheckinterval_doc,
-"getcheckinterval() -> current check interval; see setcheckinterval()."
-);
+/*[clinic input]
+sys.setswitchinterval
+
+    interval: double
+    /
+
+Set the ideal thread switching delay inside the Python interpreter.
+
+The actual frequency of switching threads can be lower if the
+interpreter executes long sequences of uninterruptible code
+(this is implementation-specific and workload-dependent).
+
+The parameter must represent the desired switching delay in seconds
+A typical value is 0.005 (5 milliseconds).
+[clinic start generated code]*/
 
 static PyObject *
-sys_setswitchinterval(PyObject *self, PyObject *args)
+sys_setswitchinterval_impl(PyObject *module, double interval)
+/*[clinic end generated code: output=65a19629e5153983 input=561b477134df91d9]*/
 {
-    double d;
-    if (!PyArg_ParseTuple(args, "d:setswitchinterval", &d))
-        return NULL;
-    if (d <= 0.0) {
+    if (interval <= 0.0) {
         PyErr_SetString(PyExc_ValueError,
                         "switch interval must be strictly positive");
         return NULL;
     }
-    _PyEval_SetSwitchInterval((unsigned long) (1e6 * d));
+    _PyEval_SetSwitchInterval((unsigned long) (1e6 * interval));
     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)
+/*[clinic input]
+sys.getswitchinterval -> double
+
+Return the current thread switch interval; see sys.setswitchinterval().
+[clinic start generated code]*/
+
+static double
+sys_getswitchinterval_impl(PyObject *module)
+/*[clinic end generated code: output=a38c277c85b5096d input=bdf9d39c0ebbbb6f]*/
 {
-    return PyFloat_FromDouble(1e-6 * _PyEval_GetSwitchInterval());
+    return 1e-6 * _PyEval_GetSwitchInterval();
 }
 
-PyDoc_STRVAR(getswitchinterval_doc,
-"getswitchinterval() -> current thread switch interval; see setswitchinterval()."
-);
+/*[clinic input]
+sys.setrecursionlimit
+
+    limit as new_limit: int
+    /
+
+Set the maximum depth of the Python interpreter stack to n.
+
+This limit prevents infinite recursion from causing an overflow of the C
+stack and crashing Python.  The highest possible limit is platform-
+dependent.
+[clinic start generated code]*/
 
 static PyObject *
-sys_setrecursionlimit(PyObject *self, PyObject *args)
+sys_setrecursionlimit_impl(PyObject *module, int new_limit)
+/*[clinic end generated code: output=35e1c64754800ace input=b0f7a23393924af3]*/
 {
-    int new_limit, mark;
+    int 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");
@@ -736,14 +784,15 @@ sys.set_coroutine_origin_tracking_depth
 
 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.
+Coroutine objects will track 'depth' frames of traceback information
+about where they came from, available in their cr_origin attribute.
+
+Set a 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]*/
+/*[clinic end generated code: output=0a2123c1cc6759c5 input=a1d0a05f89d2c426]*/
 {
     if (depth < 0) {
         PyErr_SetString(PyExc_ValueError, "depth must be >= 0");
@@ -766,8 +815,18 @@ sys_get_coroutine_origin_tracking_depth_impl(PyObject *module)
     return _PyEval_GetCoroutineOriginTrackingDepth();
 }
 
+/*[clinic input]
+sys.set_coroutine_wrapper
+
+    wrapper: object
+    /
+
+Set a wrapper for coroutine objects.
+[clinic start generated code]*/
+
 static PyObject *
-sys_set_coroutine_wrapper(PyObject *self, PyObject *wrapper)
+sys_set_coroutine_wrapper(PyObject *module, PyObject *wrapper)
+/*[clinic end generated code: output=9c7db52d65f6b188 input=df6ac09a06afef34]*/
 {
     if (PyErr_WarnEx(PyExc_DeprecationWarning,
                      "set_coroutine_wrapper is deprecated", 1) < 0) {
@@ -789,14 +848,15 @@ sys_set_coroutine_wrapper(PyObject *self, PyObject *wrapper)
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(set_coroutine_wrapper_doc,
-"set_coroutine_wrapper(wrapper)\n\
-\n\
-Set a wrapper for coroutine objects."
-);
+/*[clinic input]
+sys.get_coroutine_wrapper
+
+Return the wrapper for coroutines set by sys.set_coroutine_wrapper.
+[clinic start generated code]*/
 
 static PyObject *
-sys_get_coroutine_wrapper(PyObject *self, PyObject *args)
+sys_get_coroutine_wrapper_impl(PyObject *module)
+/*[clinic end generated code: output=b74a7e4b14fe898e input=ef0351fb9ece0bb4]*/
 {
     if (PyErr_WarnEx(PyExc_DeprecationWarning,
                      "get_coroutine_wrapper is deprecated", 1) < 0) {
@@ -810,12 +870,6 @@ sys_get_coroutine_wrapper(PyObject *self, PyObject *args)
     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;
 
@@ -838,7 +892,6 @@ static PyStructSequence_Desc asyncgen_hooks_desc = {
     2
 };
 
-
 static PyObject *
 sys_set_asyncgen_hooks(PyObject *self, PyObject *args, PyObject *kw)
 {
@@ -882,13 +935,22 @@ sys_set_asyncgen_hooks(PyObject *self, PyObject *args, PyObject *kw)
 }
 
 PyDoc_STRVAR(set_asyncgen_hooks_doc,
-"set_asyncgen_hooks(*, firstiter=None, finalizer=None)\n\
+"set_asyncgen_hooks(* [, firstiter] [, finalizer])\n\
 \n\
 Set a finalizer for async generators objects."
 );
 
+/*[clinic input]
+sys.get_asyncgen_hooks
+
+Return the installed asynchronous generators hooks.
+
+This returns a namedtuple of the form (firstiter, finalizer).
+[clinic start generated code]*/
+
 static PyObject *
-sys_get_asyncgen_hooks(PyObject *self, PyObject *args)
+sys_get_asyncgen_hooks_impl(PyObject *module)
+/*[clinic end generated code: output=53a253707146f6cf input=3676b9ea62b14625]*/
 {
     PyObject *res;
     PyObject *firstiter = _PyEval_GetAsyncGenFirstiter();
@@ -916,13 +978,6 @@ sys_get_asyncgen_hooks(PyObject *self, PyObject *args)
     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;
 
@@ -988,45 +1043,24 @@ get_hash_info(void)
     }
     return hash_info;
 }
+/*[clinic input]
+sys.getrecursionlimit
 
+Return the current value of the recursion limit.
 
-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."
-);
+The recursion limit is the maximum depth of the Python interpreter
+stack.  This limit prevents infinite recursion from causing an overflow
+of the C stack and crashing Python.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getrecursionlimit(PyObject *self, PyObject *Py_UNUSED(ignored))
+sys_getrecursionlimit_impl(PyObject *module)
+/*[clinic end generated code: output=d571fb6b4549ef2e input=1c6129fd2efaeea8]*/
 {
     return PyLong_FromLong(Py_GetRecursionLimit());
 }
 
-PyDoc_STRVAR(getrecursionlimit_doc,
-"getrecursionlimit()\n\
-\n\
-Return the current value of the recursion limit, the maximum depth\n\
-of the Python interpreter stack.  This limit prevents infinite\n\
-recursion from causing an overflow of the C stack and crashing Python."
-);
-
 #ifdef MS_WINDOWS
-PyDoc_STRVAR(getwindowsversion_doc,
-"getwindowsversion()\n\
-\n\
-Return information about the running version of Windows as a named tuple.\n\
-The members are named: major, minor, build, platform, service_pack,\n\
-service_pack_major, service_pack_minor, suite_mask, and product_type. For\n\
-backward compatibility, only the first 5 items are available by indexing.\n\
-All elements are numbers, except service_pack and platform_type which are\n\
-strings, and platform_version which is a 3-tuple. Platform is always 2.\n\
-Product_type may be 1 for a workstation, 2 for a domain controller, 3 for a\n\
-server. Platform_version is a 3-tuple containing a version number that is\n\
-intended for identifying the OS rather than feature detection."
-);
 
 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
 
@@ -1046,7 +1080,7 @@ static PyStructSequence_Field windows_version_fields[] = {
 
 static PyStructSequence_Desc windows_version_desc = {
     "sys.getwindowsversion",       /* name */
-    getwindowsversion_doc,    /* doc */
+    sys_getwindowsversion__doc__,  /* doc */
     windows_version_fields,        /* fields */
     5                              /* For backward compatibility,
                                       only the first 5 items are accessible
@@ -1059,8 +1093,25 @@ static PyStructSequence_Desc windows_version_desc = {
 #pragma warning(push)
 #pragma warning(disable:4996)
 
+/*[clinic input]
+sys.getwindowsversion
+
+Return info about the running version of Windows as a named tuple.
+
+The members are named: major, minor, build, platform, service_pack,
+service_pack_major, service_pack_minor, suite_mask, product_type and
+platform_version. For backward compatibility, only the first 5 items
+are available by indexing. All elements are numbers, except
+service_pack and platform_type which are strings, and platform_version
+which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
+workstation, 2 for a domain controller, 3 for a server.
+Platform_version is a 3-tuple containing a version number that is
+intended for identifying the OS rather than feature detection.
+[clinic start generated code]*/
+
 static PyObject *
-sys_getwindowsversion(PyObject *self)
+sys_getwindowsversion_impl(PyObject *module)
+/*[clinic end generated code: output=1ec063280b932857 input=73a228a328fee63a]*/
 {
     PyObject *version;
     int pos = 0;
@@ -1128,18 +1179,21 @@ sys_getwindowsversion(PyObject *self)
 
 #pragma warning(pop)
 
-PyDoc_STRVAR(enablelegacywindowsfsencoding_doc,
-"_enablelegacywindowsfsencoding()\n\
-\n\
-Changes the default filesystem encoding to mbcs:replace for consistency\n\
-with earlier versions of Python. See PEP 529 for more information.\n\
-\n\
-This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING\n\
-environment variable before launching Python."
-);
+/*[clinic input]
+sys._enablelegacywindowsfsencoding
+
+Changes the default filesystem encoding to mbcs:replace.
+
+This is done for consistency with earlier versions of Python. See PEP
+529 for more information.
+
+This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING
+environment variable before launching Python.
+[clinic start generated code]*/
 
 static PyObject *
-sys_enablelegacywindowsfsencoding(PyObject *self)
+sys__enablelegacywindowsfsencoding_impl(PyObject *module)
+/*[clinic end generated code: output=f5c3855b45e24fe9 input=2bfa931a20704492]*/
 {
     PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();
     _PyCoreConfig *config = &interp->core_config;
@@ -1171,52 +1225,68 @@ sys_enablelegacywindowsfsencoding(PyObject *self)
 #endif /* MS_WINDOWS */
 
 #ifdef HAVE_DLOPEN
+
+/*[clinic input]
+sys.setdlopenflags
+
+    flags as new_val: int
+    /
+
+Set the flags used by the interpreter for dlopen calls.
+
+This is used, for example, when the interpreter loads extension
+modules. Among other things, this will enable a lazy resolving of
+symbols when importing a module, if called as sys.setdlopenflags(0).
+To share symbols across extension modules, call as
+sys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag
+modules can be found in the os module (RTLD_xxx constants, e.g.
+os.RTLD_LAZY).
+[clinic start generated code]*/
+
 static PyObject *
-sys_setdlopenflags(PyObject *self, PyObject *args)
+sys_setdlopenflags_impl(PyObject *module, int new_val)
+/*[clinic end generated code: output=ec918b7fe0a37281 input=4c838211e857a77f]*/
 {
-    int new_val;
-    if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
-        return NULL;
     PyInterpreterState *interp = _PyInterpreterState_Get();
     interp->dlopenflags = new_val;
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(setdlopenflags_doc,
-"setdlopenflags(n) -> None\n\
-\n\
-Set the flags used by the interpreter for dlopen calls, such as when the\n\
-interpreter loads extension modules.  Among other things, this will enable\n\
-a lazy resolving of symbols when importing a module, if called as\n\
-sys.setdlopenflags(0).  To share symbols across extension modules, call as\n\
-sys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag modules\n\
-can be found in the os module (RTLD_xxx constants, e.g. os.RTLD_LAZY).");
+
+/*[clinic input]
+sys.getdlopenflags
+
+Return the current value of the flags that are used for dlopen calls.
+
+The flag constants are defined in the os module.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getdlopenflags(PyObject *self, PyObject *args)
+sys_getdlopenflags_impl(PyObject *module)
+/*[clinic end generated code: output=e92cd1bc5005da6e input=dc4ea0899c53b4b6]*/
 {
     PyInterpreterState *interp = _PyInterpreterState_Get();
     return PyLong_FromLong(interp->dlopenflags);
 }
 
-PyDoc_STRVAR(getdlopenflags_doc,
-"getdlopenflags() -> int\n\
-\n\
-Return the current value of the flags that are used for dlopen calls.\n\
-The flag constants are defined in the os module.");
-
 #endif  /* HAVE_DLOPEN */
 
 #ifdef USE_MALLOPT
 /* Link with -lmalloc (or -lmpc) on an SGI */
 #include <malloc.h>
 
+/*[clinic input]
+sys.mdebug
+
+    flag: int
+    /
+[clinic start generated code]*/
+
 static PyObject *
-sys_mdebug(PyObject *self, PyObject *args)
+sys_mdebug_impl(PyObject *module, int flag)
+/*[clinic end generated code: output=5431d545847c3637 input=151d150ae1636f8a]*/
 {
     int flag;
-    if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
-        return NULL;
     mallopt(M_DEBUG, flag);
     Py_RETURN_NONE;
 }
@@ -1292,48 +1362,64 @@ sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
 }
 
 PyDoc_STRVAR(getsizeof_doc,
-"getsizeof(object, default) -> int\n\
+"getsizeof(object [, default]) -> int\n\
 \n\
 Return the size of object in bytes.");
 
-static PyObject *
-sys_getrefcount(PyObject *self, PyObject *arg)
+/*[clinic input]
+sys.getrefcount -> Py_ssize_t
+
+    object:  object
+    /
+
+Return the reference count of object.
+
+The count returned is generally one higher than you might expect,
+because it includes the (temporary) reference as an argument to
+getrefcount().
+[clinic start generated code]*/
+
+static Py_ssize_t
+sys_getrefcount_impl(PyObject *module, PyObject *object)
+/*[clinic end generated code: output=5fd477f2264b85b2 input=bf474efd50a21535]*/
 {
-    return PyLong_FromSsize_t(arg->ob_refcnt);
+    return object->ob_refcnt;
 }
 
 #ifdef Py_REF_DEBUG
-static PyObject *
-sys_gettotalrefcount(PyObject *self, PyObject *Py_UNUSED(ignored))
+/*[clinic input]
+sys.gettotalrefcount -> Py_ssize_t
+[clinic start generated code]*/
+
+static Py_ssize_t
+sys_gettotalrefcount_impl(PyObject *module)
+/*[clinic end generated code: output=4103886cf17c25bc input=53b744faa5d2e4f6]*/
 {
-    return PyLong_FromSsize_t(_Py_GetRefTotal());
+    return _Py_GetRefTotal();
 }
 #endif /* Py_REF_DEBUG */
 
-PyDoc_STRVAR(getrefcount_doc,
-"getrefcount(object) -> integer\n\
-\n\
-Return the reference count of object.  The count returned is generally\n\
-one higher than you might expect, because it includes the (temporary)\n\
-reference as an argument to getrefcount()."
-);
+/*[clinic input]
+sys.getallocatedblocks -> Py_ssize_t
 
-static PyObject *
-sys_getallocatedblocks(PyObject *self, PyObject *Py_UNUSED(ignored))
+Return the number of memory blocks currently allocated.
+[clinic start generated code]*/
+
+static Py_ssize_t
+sys_getallocatedblocks_impl(PyObject *module)
+/*[clinic end generated code: output=f0c4e873f0b6dcf7 input=dab13ee346a0673e]*/
 {
-    return PyLong_FromSsize_t(_Py_GetAllocatedBlocks());
+    return _Py_GetAllocatedBlocks();
 }
 
-PyDoc_STRVAR(getallocatedblocks_doc,
-"getallocatedblocks() -> integer\n\
-\n\
-Return the number of memory blocks currently allocated, regardless of their\n\
-size."
-);
-
 #ifdef COUNT_ALLOCS
+/*[clinic input]
+sys.getcounts
+[clinic start generated code]*/
+
 static PyObject *
-sys_getcounts(PyObject *self)
+sys_getcounts_impl(PyObject *module)
+/*[clinic end generated code: output=20df00bc164f43cb input=ad2ec7bda5424953]*/
 {
     extern PyObject *_Py_get_counts(void);
 
@@ -1341,26 +1427,28 @@ sys_getcounts(PyObject *self)
 }
 #endif
 
-PyDoc_STRVAR(getframe_doc,
-"_getframe([depth]) -> frameobject\n\
-\n\
-Return a frame object from the call stack.  If optional integer depth is\n\
-given, return the frame object that many calls below the top of the stack.\n\
-If that is deeper than the call stack, ValueError is raised.  The default\n\
-for depth is zero, returning the frame at the top of the call stack.\n\
-\n\
-This function should be used for internal and specialized\n\
-purposes only."
-);
+/*[clinic input]
+sys._getframe
+
+    depth: int = 0
+    /
+
+Return a frame object from the call stack.
+
+If optional integer depth is given, return the frame object that many
+calls below the top of the stack.  If that is deeper than the call
+stack, ValueError is raised.  The default for depth is zero, returning
+the frame at the top of the call stack.
+
+This function should be used for internal and specialized purposes
+only.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getframe(PyObject *self, PyObject *args)
+sys__getframe_impl(PyObject *module, int depth)
+/*[clinic end generated code: output=d438776c04d59804 input=c1be8a6464b11ee5]*/
 {
     PyFrameObject *f = _PyThreadState_GET()->frame;
-    int depth = -1;
-
-    if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
-        return NULL;
 
     while (depth > 0 && f != NULL) {
         f = f->f_back;
@@ -1375,63 +1463,70 @@ sys_getframe(PyObject *self, PyObject *args)
     return (PyObject*)f;
 }
 
-PyDoc_STRVAR(current_frames_doc,
-"_current_frames() -> dictionary\n\
-\n\
-Return a dictionary mapping each current thread T's thread id to T's\n\
-current stack frame.\n\
-\n\
-This function should be used for specialized purposes only."
-);
+/*[clinic input]
+sys._current_frames
+
+Return a dict mapping each thread's thread id to its current stack frame.
+
+This function should be used for specialized purposes only.
+[clinic start generated code]*/
 
 static PyObject *
-sys_current_frames(PyObject *self, PyObject *noargs)
+sys__current_frames_impl(PyObject *module)
+/*[clinic end generated code: output=d2a41ac0a0a3809a input=2a9049c5f5033691]*/
 {
     return _PyThread_CurrentFrames();
 }
 
-PyDoc_STRVAR(call_tracing_doc,
-"call_tracing(func, args) -> object\n\
-\n\
-Call func(*args), while tracing is enabled.  The tracing state is\n\
-saved, and restored afterwards.  This is intended to be called from\n\
-a debugger from a checkpoint, to recursively debug some other code."
-);
+/*[clinic input]
+sys.call_tracing
+
+    func: object
+    args as funcargs: object(subclass_of='&PyTuple_Type')
+    /
+
+Call func(*args), while tracing is enabled.
+
+The tracing state is saved, and restored afterwards.  This is intended
+to be called from a debugger from a checkpoint, to recursively debug
+some other code.
+[clinic start generated code]*/
 
 static PyObject *
-sys_call_tracing(PyObject *self, PyObject *args)
+sys_call_tracing_impl(PyObject *module, PyObject *func, PyObject *funcargs)
+/*[clinic end generated code: output=7e4999853cd4e5a6 input=5102e8b11049f92f]*/
 {
-    PyObject *func, *funcargs;
-    if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
-        return NULL;
     return _PyEval_CallTracing(func, funcargs);
 }
 
-PyDoc_STRVAR(callstats_doc,
-"callstats() -> tuple of integers\n\
-\n\
-Return a tuple of function call statistics, if CALL_PROFILE was defined\n\
-when Python was built.  Otherwise, return None.\n\
-\n\
-When enabled, this function returns detailed, implementation-specific\n\
-details about the number of function calls executed. The return value is\n\
-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()"
-);
+/*[clinic input]
+sys.callstats
+
+Return a tuple of function call statistics.
+
+A tuple is returned only if CALL_PROFILE was defined when Python was
+built.  Otherwise, this returns None.
+
+When enabled, this function returns detailed, implementation-specific
+details about the number of function calls executed. The return value
+is a 11-tuple where the entries in the tuple are counts of:
+0. all function calls
+1. calls to PyFunction_Type objects
+2. PyFunction calls that do not create an argument tuple
+3. PyFunction calls that do not create an argument tuple
+   and bypass PyEval_EvalCodeEx()
+4. PyMethod calls
+5. PyMethod calls on bound methods
+6. PyType calls
+7. PyCFunction calls
+8. generator calls
+9. All other calls
+10. Number of stack pops performed by call_function()
+[clinic start generated code]*/
 
 static PyObject *
-sys_callstats(PyObject *self, PyObject *Py_UNUSED(ignored))
+sys_callstats_impl(PyObject *module)
+/*[clinic end generated code: output=edc4a74957fa8def input=d447d8d224d5d175]*/
 {
     if (PyErr_WarnEx(PyExc_DeprecationWarning,
                       "sys.callstats() has been deprecated in Python 3.7 "
@@ -1447,8 +1542,18 @@ sys_callstats(PyObject *self, PyObject *Py_UNUSED(ignored))
 extern "C" {
 #endif
 
+/*[clinic input]
+sys._debugmallocstats
+
+Print summary info to stderr about the state of pymalloc's structures.
+
+In Py_DEBUG mode, also perform some expensive internal consistency
+checks.
+[clinic start generated code]*/
+
 static PyObject *
-sys_debugmallocstats(PyObject *self, PyObject *args)
+sys__debugmallocstats_impl(PyObject *module)
+/*[clinic end generated code: output=ec3565f8c7cee46a input=33c0c9c416f98424]*/
 {
 #ifdef WITH_PYMALLOC
     if (_PyObject_DebugMallocStats(stderr)) {
@@ -1459,15 +1564,6 @@ sys_debugmallocstats(PyObject *self, PyObject *args)
 
     Py_RETURN_NONE;
 }
-PyDoc_STRVAR(debugmallocstats_doc,
-"_debugmallocstats()\n\
-\n\
-Print summary info to stderr about the state of\n\
-pymalloc's structures.\n\
-\n\
-In Py_DEBUG mode, also perform some expensive internal consistency\n\
-checks.\n\
-");
 
 #ifdef Py_TRACE_REFS
 /* Defined in objects.c because it uses static globals if that file */
@@ -1483,8 +1579,16 @@ extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
 }
 #endif
 
+
+/*[clinic input]
+sys._clear_type_cache
+
+Clear the internal type lookup cache.
+[clinic start generated code]*/
+
 static PyObject *
-sys_clear_type_cache(PyObject* self, PyObject* args)
+sys__clear_type_cache_impl(PyObject *module)
+/*[clinic end generated code: output=20e48ca54a6f6971 input=127f3e04a8d9b555]*/
 {
     PyType_ClearCache();
     Py_RETURN_NONE;
@@ -1494,25 +1598,29 @@ PyDoc_STRVAR(sys_clear_type_cache__doc__,
 "_clear_type_cache() -> None\n\
 Clear the internal type lookup cache.");
 
+/*[clinic input]
+sys.is_finalizing
+
+Return True if Python is exiting.
+[clinic start generated code]*/
+
 static PyObject *
-sys_is_finalizing(PyObject* self, PyObject* args)
+sys_is_finalizing_impl(PyObject *module)
+/*[clinic end generated code: output=735b5ff7962ab281 input=f0df747a039948a5]*/
 {
     return PyBool_FromLong(_Py_IsFinalizing());
 }
 
-PyDoc_STRVAR(is_finalizing_doc,
-"is_finalizing()\n\
-Return True if Python is exiting.");
-
-
 #ifdef ANDROID_API_LEVEL
-PyDoc_STRVAR(getandroidapilevel_doc,
-"getandroidapilevel()\n\
-\n\
-Return the build time API version of Android as an integer.");
+/*[clinic input]
+sys.getandroidapilevel
+
+Return the build time API version of Android as an integer.
+[clinic start generated code]*/
 
 static PyObject *
-sys_getandroidapilevel(PyObject *self)
+sys_getandroidapilevel_impl(PyObject *module)
+/*[clinic end generated code: output=214abf183a1c70c1 input=3e6d6c9fcdd24ac6]*/
 {
     return PyLong_FromLong(ANDROID_API_LEVEL);
 }
@@ -1523,92 +1631,56 @@ static PyMethodDef sys_methods[] = {
     /* Might as well keep this in alphabetic order */
     {"breakpointhook",  (PyCFunction)(void(*)(void))sys_breakpointhook,
      METH_FASTCALL | METH_KEYWORDS, breakpointhook_doc},
-    {"callstats", sys_callstats, METH_NOARGS,
-     callstats_doc},
-    {"_clear_type_cache",       sys_clear_type_cache,     METH_NOARGS,
-     sys_clear_type_cache__doc__},
-    {"_current_frames", sys_current_frames, METH_NOARGS,
-     current_frames_doc},
-    {"displayhook",     sys_displayhook, METH_O, displayhook_doc},
-    {"exc_info",        sys_exc_info, METH_NOARGS, exc_info_doc},
-    {"excepthook",      sys_excepthook, METH_VARARGS, excepthook_doc},
-    {"exit",            sys_exit, METH_VARARGS, exit_doc},
-    {"getdefaultencoding", sys_getdefaultencoding,
-     METH_NOARGS, getdefaultencoding_doc},
-#ifdef HAVE_DLOPEN
-    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
-     getdlopenflags_doc},
-#endif
-    {"getallocatedblocks", sys_getallocatedblocks, METH_NOARGS,
-      getallocatedblocks_doc},
-#ifdef COUNT_ALLOCS
-    {"getcounts",       (PyCFunction)sys_getcounts, METH_NOARGS},
-#endif
+    SYS_CALLSTATS_METHODDEF
+    SYS__CLEAR_TYPE_CACHE_METHODDEF
+    SYS__CURRENT_FRAMES_METHODDEF
+    SYS_DISPLAYHOOK_METHODDEF
+    SYS_EXC_INFO_METHODDEF
+    SYS_EXCEPTHOOK_METHODDEF
+    SYS_EXIT_METHODDEF
+    SYS_GETDEFAULTENCODING_METHODDEF
+    SYS_GETDLOPENFLAGS_METHODDEF
+    SYS_GETALLOCATEDBLOCKS_METHODDEF
+    SYS_GETCOUNTS_METHODDEF
 #ifdef DYNAMIC_EXECUTION_PROFILE
     {"getdxp",          _Py_GetDXProfile, METH_VARARGS},
 #endif
-    {"getfilesystemencoding", sys_getfilesystemencoding,
-     METH_NOARGS, getfilesystemencoding_doc},
-    { "getfilesystemencodeerrors", sys_getfilesystemencodeerrors,
-     METH_NOARGS, getfilesystemencodeerrors_doc },
+    SYS_GETFILESYSTEMENCODING_METHODDEF
+    SYS_GETFILESYSTEMENCODEERRORS_METHODDEF
 #ifdef Py_TRACE_REFS
     {"getobjects",      _Py_GetObjects, METH_VARARGS},
 #endif
-#ifdef Py_REF_DEBUG
-    {"gettotalrefcount", sys_gettotalrefcount, METH_NOARGS},
-#endif
-    {"getrefcount",     (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
-    {"getrecursionlimit", sys_getrecursionlimit, METH_NOARGS,
-     getrecursionlimit_doc},
+    SYS_GETTOTALREFCOUNT_METHODDEF
+    SYS_GETREFCOUNT_METHODDEF
+    SYS_GETRECURSIONLIMIT_METHODDEF
     {"getsizeof",   (PyCFunction)(void(*)(void))sys_getsizeof,
      METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
-    {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
-#ifdef MS_WINDOWS
-    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
-     getwindowsversion_doc},
-    {"_enablelegacywindowsfsencoding", (PyCFunction)sys_enablelegacywindowsfsencoding,
-     METH_NOARGS, enablelegacywindowsfsencoding_doc },
-#endif /* MS_WINDOWS */
-    {"intern",          sys_intern,     METH_VARARGS, intern_doc},
-    {"is_finalizing",   sys_is_finalizing, METH_NOARGS, is_finalizing_doc},
-#ifdef USE_MALLOPT
-    {"mdebug",          sys_mdebug, METH_VARARGS},
-#endif
-    {"setcheckinterval",        sys_setcheckinterval, METH_VARARGS,
-     setcheckinterval_doc},
-    {"getcheckinterval",        sys_getcheckinterval, METH_NOARGS,
-     getcheckinterval_doc},
-    {"setswitchinterval",       sys_setswitchinterval, METH_VARARGS,
-     setswitchinterval_doc},
-    {"getswitchinterval",       sys_getswitchinterval, METH_NOARGS,
-     getswitchinterval_doc},
-#ifdef HAVE_DLOPEN
-    {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
-     setdlopenflags_doc},
-#endif
+    SYS__GETFRAME_METHODDEF
+    SYS_GETWINDOWSVERSION_METHODDEF
+    SYS__ENABLELEGACYWINDOWSFSENCODING_METHODDEF
+    SYS_INTERN_METHODDEF
+    SYS_IS_FINALIZING_METHODDEF
+    SYS_MDEBUG_METHODDEF
+    SYS_SETCHECKINTERVAL_METHODDEF
+    SYS_GETCHECKINTERVAL_METHODDEF
+    SYS_SETSWITCHINTERVAL_METHODDEF
+    SYS_GETSWITCHINTERVAL_METHODDEF
+    SYS_SETDLOPENFLAGS_METHODDEF
     {"setprofile",      sys_setprofile, METH_O, setprofile_doc},
-    {"getprofile",      sys_getprofile, METH_NOARGS, getprofile_doc},
-    {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
-     setrecursionlimit_doc},
+    SYS_GETPROFILE_METHODDEF
+    SYS_SETRECURSIONLIMIT_METHODDEF
     {"settrace",        sys_settrace, METH_O, settrace_doc},
-    {"gettrace",        sys_gettrace, METH_NOARGS, gettrace_doc},
-    {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
-    {"_debugmallocstats", sys_debugmallocstats, METH_NOARGS,
-     debugmallocstats_doc},
+    SYS_GETTRACE_METHODDEF
+    SYS_CALL_TRACING_METHODDEF
+    SYS__DEBUGMALLOCSTATS_METHODDEF
     SYS_SET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF
     SYS_GET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF
-    {"set_coroutine_wrapper", sys_set_coroutine_wrapper, METH_O,
-     set_coroutine_wrapper_doc},
-    {"get_coroutine_wrapper", sys_get_coroutine_wrapper, METH_NOARGS,
-     get_coroutine_wrapper_doc},
+    SYS_SET_COROUTINE_WRAPPER_METHODDEF
+    SYS_GET_COROUTINE_WRAPPER_METHODDEF
     {"set_asyncgen_hooks", (PyCFunction)(void(*)(void))sys_set_asyncgen_hooks,
      METH_VARARGS | METH_KEYWORDS, set_asyncgen_hooks_doc},
-    {"get_asyncgen_hooks", sys_get_asyncgen_hooks, METH_NOARGS,
-     get_asyncgen_hooks_doc},
-#ifdef ANDROID_API_LEVEL
-    {"getandroidapilevel", (PyCFunction)sys_getandroidapilevel, METH_NOARGS,
-     getandroidapilevel_doc},
-#endif
+    SYS_GET_ASYNCGEN_HOOKS_METHODDEF
+    SYS_GETANDROIDAPILEVEL_METHODDEF
     {NULL,              NULL}           /* sentinel */
 };