/home/mdboom/Work/builds/cpython/Python/clinic/import.c.h

Source (jump to first uncovered line)
/*[clinic input]
preserve
[clinic start generated code]*/

PyDoc_STRVAR(_imp_lock_held__doc__,
"lock_held($module, /)\n"
"--\n"
"\n"
"Return True if the import lock is currently held, else False.\n"
"\n"
"On platforms without threads, return False.");

#define _IMP_LOCK_HELD_METHODDEF    \
    {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__},

static PyObject *
_imp_lock_held_impl(PyObject *module);

static PyObject *
_imp_lock_held(PyObject *module, PyObject *Py_UNUSED(ignored))
{
    return _imp_lock_held_impl(module);
}

PyDoc_STRVAR(_imp_acquire_lock__doc__,
"acquire_lock($module, /)\n"
"--\n"
"\n"
"Acquires the interpreter\'s import lock for the current thread.\n"
"\n"
"This lock should be used by import hooks to ensure thread-safety when importing\n"
"modules. On platforms without threads, this function does nothing.");

#define _IMP_ACQUIRE_LOCK_METHODDEF    \
    {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__},

static PyObject *
_imp_acquire_lock_impl(PyObject *module);

static PyObject *
_imp_acquire_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
{
    return _imp_acquire_lock_impl(module);
}

PyDoc_STRVAR(_imp_release_lock__doc__,
"release_lock($module, /)\n"
"--\n"
"\n"
"Release the interpreter\'s import lock.\n"
"\n"
"On platforms without threads, this function does nothing.");

#define _IMP_RELEASE_LOCK_METHODDEF    \
    {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__},

static PyObject *
_imp_release_lock_impl(PyObject *module);

static PyObject *
_imp_release_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
{
    return _imp_release_lock_impl(module);
}

PyDoc_STRVAR(_imp__fix_co_filename__doc__,
"_fix_co_filename($module, code, path, /)\n"
"--\n"
"\n"
"Changes code.co_filename to specify the passed-in file path.\n"
"\n"
"  code\n"
"    Code object to change.\n"
"  path\n"
"    File path to use.");

#define _IMP__FIX_CO_FILENAME_METHODDEF    \
    {"_fix_co_filename", _PyCFunction_CAST(_imp__fix_co_filename), METH_FASTCALL, _imp__fix_co_filename__doc__},

static PyObject *
_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
                           PyObject *path);

static PyObject *
_imp__fix_co_filename(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyCodeObject *code;
    PyObject *path;

    if (!_PyArg_CheckPositional("_fix_co_filename", nargs, 2, 2)) {
        goto exit;
    }
    if (!PyObject_TypeCheck(args[0], &PyCode_Type)) {
        _PyArg_BadArgument("_fix_co_filename", "argument 1", (&PyCode_Type)->tp_name, args[0]);
        goto exit;
    }
    code = (PyCodeObject *)args[0];
    if (!PyUnicode_Check(args[1])) {
        _PyArg_BadArgument("_fix_co_filename", "argument 2", "str", args[1]);
        goto exit;
    }
    if (PyUnicode_READY(args[1]) == -1) {
        goto exit;
    }
    path = args[1];
    return_value = _imp__fix_co_filename_impl(module, code, path);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_create_builtin__doc__,
"create_builtin($module, spec, /)\n"
"--\n"
"\n"
"Create an extension module.");

#define _IMP_CREATE_BUILTIN_METHODDEF    \
    {"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, _imp_create_builtin__doc__},

PyDoc_STRVAR(_imp_extension_suffixes__doc__,
"extension_suffixes($module, /)\n"
"--\n"
"\n"
"Returns the list of file suffixes used to identify extension modules.");

#define _IMP_EXTENSION_SUFFIXES_METHODDEF    \
    {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__},

static PyObject *
_imp_extension_suffixes_impl(PyObject *module);

static PyObject *
_imp_extension_suffixes(PyObject *module, PyObject *Py_UNUSED(ignored))
{
    return _imp_extension_suffixes_impl(module);
}

PyDoc_STRVAR(_imp_init_frozen__doc__,
"init_frozen($module, name, /)\n"
"--\n"
"\n"
"Initializes a frozen module.");

#define _IMP_INIT_FROZEN_METHODDEF    \
    {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__},

static PyObject *
_imp_init_frozen_impl(PyObject *module, PyObject *name);

static PyObject *
_imp_init_frozen(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyObject *name;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("init_frozen", "argument", "str", arg);
        goto exit;
    }
    if (PyUnicode_READY(arg) == -1) {
        goto exit;
    }
    name = arg;
    return_value = _imp_init_frozen_impl(module, name);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_find_frozen__doc__,
"find_frozen($module, name, /, *, withdata=False)\n"
"--\n"
"\n"
"Return info about the corresponding frozen module (if there is one) or None.\n"
"\n"
"The returned info (a 2-tuple):\n"
"\n"
" * data         the raw marshalled bytes\n"
" * is_package   whether or not it is a package\n"
" * origname     the originally frozen module\'s name, or None if not\n"
"                a stdlib module (this will usually be the same as\n"
"                the module\'s current name)");

#define _IMP_FIND_FROZEN_METHODDEF    \
    {"find_frozen", _PyCFunction_CAST(_imp_find_frozen), METH_FASTCALL|METH_KEYWORDS, _imp_find_frozen__doc__},

static PyObject *
_imp_find_frozen_impl(PyObject *module, PyObject *name, int withdata);

static PyObject *
_imp_find_frozen(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"", "withdata", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "find_frozen", 0};
    PyObject *argsbuf[2];
    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE0(kwnames) : 0) - 1;
    PyObject *name;
    int withdata = 0;

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    if (!PyUnicode_Check(args[0])) {
        _PyArg_BadArgument("find_frozen", "argument 1", "str", args[0]);
        goto exit;
    }
    if (PyUnicode_READY(args[0]) == -1) {
        goto exit;
    }
    name = args[0];
    if (!noptargs) {
        goto skip_optional_kwonly;
    }
    withdata = PyObject_IsTrue(args[1]);
    if (withdata < 0) {
        goto exit;
    }
skip_optional_kwonly:
    return_value = _imp_find_frozen_impl(module, name, withdata);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_get_frozen_object__doc__,
"get_frozen_object($module, name, data=None, /)\n"
"--\n"
"\n"
"Create a code object for a frozen module.");

#define _IMP_GET_FROZEN_OBJECT_METHODDEF    \
    {"get_frozen_object", _PyCFunction_CAST(_imp_get_frozen_object), METH_FASTCALL, _imp_get_frozen_object__doc__},

static PyObject *
_imp_get_frozen_object_impl(PyObject *module, PyObject *name,
                            PyObject *dataobj);

static PyObject *
_imp_get_frozen_object(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *name;
    PyObject *dataobj = Py_None;

    if (!_PyArg_CheckPositional("get_frozen_object", nargs, 1, 2)) {
        goto exit;
    }
    if (!PyUnicode_Check(args[0])) {
        _PyArg_BadArgument("get_frozen_object", "argument 1", "str", args[0]);
        goto exit;
    }
    if (PyUnicode_READY(args[0]) == -1) {
        goto exit;
    }
    name = args[0];
    if (nargs < 2) {
        goto skip_optional;
    }
    dataobj = args[1];
skip_optional:
    return_value = _imp_get_frozen_object_impl(module, name, dataobj);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_is_frozen_package__doc__,
"is_frozen_package($module, name, /)\n"
"--\n"
"\n"
"Returns True if the module name is of a frozen package.");

#define _IMP_IS_FROZEN_PACKAGE_METHODDEF    \
    {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__},

static PyObject *
_imp_is_frozen_package_impl(PyObject *module, PyObject *name);

static PyObject *
_imp_is_frozen_package(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyObject *name;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("is_frozen_package", "argument", "str", arg);
        goto exit;
    }
    if (PyUnicode_READY(arg) == -1) {
        goto exit;
    }
    name = arg;
    return_value = _imp_is_frozen_package_impl(module, name);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_is_builtin__doc__,
"is_builtin($module, name, /)\n"
"--\n"
"\n"
"Returns True if the module name corresponds to a built-in module.");

#define _IMP_IS_BUILTIN_METHODDEF    \
    {"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__},

static PyObject *
_imp_is_builtin_impl(PyObject *module, PyObject *name);

static PyObject *
_imp_is_builtin(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyObject *name;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("is_builtin", "argument", "str", arg);
        goto exit;
    }
    if (PyUnicode_READY(arg) == -1) {
        goto exit;
    }
    name = arg;
    return_value = _imp_is_builtin_impl(module, name);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_is_frozen__doc__,
"is_frozen($module, name, /)\n"
"--\n"
"\n"
"Returns True if the module name corresponds to a frozen module.");

#define _IMP_IS_FROZEN_METHODDEF    \
    {"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__},

static PyObject *
_imp_is_frozen_impl(PyObject *module, PyObject *name);

static PyObject *
_imp_is_frozen(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyObject *name;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("is_frozen", "argument", "str", arg);
        goto exit;
    }
    if (PyUnicode_READY(arg) == -1) {
        goto exit;
    }
    name = arg;
    return_value = _imp_is_frozen_impl(module, name);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp__frozen_module_names__doc__,
"_frozen_module_names($module, /)\n"
"--\n"
"\n"
"Returns the list of available frozen modules.");

#define _IMP__FROZEN_MODULE_NAMES_METHODDEF    \
    {"_frozen_module_names", (PyCFunction)_imp__frozen_module_names, METH_NOARGS, _imp__frozen_module_names__doc__},

static PyObject *
_imp__frozen_module_names_impl(PyObject *module);

static PyObject *
_imp__frozen_module_names(PyObject *module, PyObject *Py_UNUSED(ignored))
{
    return _imp__frozen_module_names_impl(module);
}

PyDoc_STRVAR(_imp__override_frozen_modules_for_tests__doc__,
"_override_frozen_modules_for_tests($module, override, /)\n"
"--\n"
"\n"
"(internal-only) Override PyConfig.use_frozen_modules.\n"
"\n"
"(-1: \"off\", 1: \"on\", 0: no override)\n"
"See frozen_modules() in Lib/test/support/import_helper.py.");

#define _IMP__OVERRIDE_FROZEN_MODULES_FOR_TESTS_METHODDEF    \
    {"_override_frozen_modules_for_tests", (PyCFunction)_imp__override_frozen_modules_for_tests, METH_O, _imp__override_frozen_modules_for_tests__doc__},

static PyObject *
_imp__override_frozen_modules_for_tests_impl(PyObject *module, int override);

static PyObject *
_imp__override_frozen_modules_for_tests(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    int override;

    override = _PyLong_AsInt(arg);
    if (override == -1 && PyErr_Occurred()191) {
        goto exit;
    }
    return_value = _imp__override_frozen_modules_for_tests_impl(module, override);

exit:
    return return_value;
}

#if defined(HAVE_DYNAMIC_LOADING)

PyDoc_STRVAR(_imp_create_dynamic__doc__,
"create_dynamic($module, spec, file=<unrepresentable>, /)\n"
"--\n"
"\n"
"Create an extension module.");

#define _IMP_CREATE_DYNAMIC_METHODDEF    \
    {"create_dynamic", _PyCFunction_CAST(_imp_create_dynamic), METH_FASTCALL, _imp_create_dynamic__doc__},

static PyObject *
_imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file);

static PyObject *
_imp_create_dynamic(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *spec;
    PyObject *file = NULL;

    if (!_PyArg_CheckPositional("create_dynamic", nargs, 1, 2)) {
        goto exit;
    }
    spec = args[0];
    if (nargs < 2) {
        goto skip_optional;
    }
    file = args[1];
skip_optional:
    return_value = _imp_create_dynamic_impl(module, spec, file);

exit:
    return return_value;
}

#endif /* defined(HAVE_DYNAMIC_LOADING) */

#if defined(HAVE_DYNAMIC_LOADING)

PyDoc_STRVAR(_imp_exec_dynamic__doc__,
"exec_dynamic($module, mod, /)\n"
"--\n"
"\n"
"Initialize an extension module.");

#define _IMP_EXEC_DYNAMIC_METHODDEF    \
    {"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, _imp_exec_dynamic__doc__},

static int
_imp_exec_dynamic_impl(PyObject *module, PyObject *mod);

static PyObject *
_imp_exec_dynamic(PyObject *module, PyObject *mod)
{
    PyObject *return_value = NULL;
    int _return_value;

    _return_value = _imp_exec_dynamic_impl(module, mod);
    if ((_return_value == -1) && PyErr_Occurred()6) {
        goto exit;
    }
    return_value = PyLong_FromLong((long)_return_value);

exit:
    return return_value;
}

#endif /* defined(HAVE_DYNAMIC_LOADING) */

PyDoc_STRVAR(_imp_exec_builtin__doc__,
"exec_builtin($module, mod, /)\n"
"--\n"
"\n"
"Initialize a built-in module.");

#define _IMP_EXEC_BUILTIN_METHODDEF    \
    {"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, _imp_exec_builtin__doc__},

static int
_imp_exec_builtin_impl(PyObject *module, PyObject *mod);

static PyObject *
_imp_exec_builtin(PyObject *module, PyObject *mod)
{
    PyObject *return_value = NULL;
    int _return_value;

    _return_value = _imp_exec_builtin_impl(module, mod);
    if ((_return_value == -1) && PyErr_Occurred()0) {
        goto exit;
    }
    return_value = PyLong_FromLong((long)_return_value);

exit:
    return return_value;
}

PyDoc_STRVAR(_imp_source_hash__doc__,
"source_hash($module, /, key, source)\n"
"--\n"
"\n");

#define _IMP_SOURCE_HASH_METHODDEF    \
    {"source_hash", _PyCFunction_CAST(_imp_source_hash), METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},

static PyObject *
_imp_source_hash_impl(PyObject *module, long key, Py_buffer *source);

static PyObject *
_imp_source_hash(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
    PyObject *return_value = NULL;
    static const char * const _keywords[] = {"key", "source", NULL};
    static _PyArg_Parser _parser = {NULL, _keywords, "source_hash", 0};
    PyObject *argsbuf[2];
    long key;
    Py_buffer source = {NULL, NULL};

    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
    if (!args) {
        goto exit;
    }
    key = PyLong_AsLong(args[0]);
    if (key == -1 && PyErr_Occurred()0) {
        goto exit;
    }
    if (PyObject_GetBuffer(args[1], &source, PyBUF_SIMPLE) != 0) {
        goto exit;
    }
    if (!PyBuffer_IsContiguous(&source, 'C')) {
        _PyArg_BadArgument("source_hash", "argument 'source'", "contiguous buffer", args[1]);
        goto exit;
    }
    return_value = _imp_source_hash_impl(module, key, &source);

exit:
    /* Cleanup for source */
    if (source.obj) {
       PyBuffer_Release(&source);
    }

    return return_value;
}

#ifndef _IMP_CREATE_DYNAMIC_METHODDEF
    #define _IMP_CREATE_DYNAMIC_METHODDEF
#endif /* !defined(_IMP_CREATE_DYNAMIC_METHODDEF) */

#ifndef _IMP_EXEC_DYNAMIC_METHODDEF
    #define _IMP_EXEC_DYNAMIC_METHODDEF
#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
/*[clinic end generated code: output=8d0f4305b1d0714b input=a9049054013a1b77]*/

Coverage Report

Created: 2022-07-08 09:39

Line	Count	Source (jump to first uncovered line)
1	/*[clinic input]
2	preserve
3	[clinic start generated code]*/
4
5	PyDoc_STRVAR(_imp_lock_held__doc__,
6	"lock_held($module, /)\n"
7	"--\n"
8	"\n"
9	"Return True if the import lock is currently held, else False.\n"
10	"\n"
11	"On platforms without threads, return False.");
12
13	#define _IMP_LOCK_HELD_METHODDEF \
14	{"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__},
15
16	static PyObject *
17	_imp_lock_held_impl(PyObject *module);
18
19	static PyObject *
20	_imp_lock_held(PyObject module, PyObject Py_UNUSED(ignored))
21	{
22	return _imp_lock_held_impl(module);
23	}
24
25	PyDoc_STRVAR(_imp_acquire_lock__doc__,
26	"acquire_lock($module, /)\n"
27	"--\n"
28	"\n"
29	"Acquires the interpreter\'s import lock for the current thread.\n"
30	"\n"
31	"This lock should be used by import hooks to ensure thread-safety when importing\n"
32	"modules. On platforms without threads, this function does nothing.");
33
34	#define _IMP_ACQUIRE_LOCK_METHODDEF \
35	{"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__},
36
37	static PyObject *
38	_imp_acquire_lock_impl(PyObject *module);
39
40	static PyObject *
41	_imp_acquire_lock(PyObject module, PyObject Py_UNUSED(ignored))
42	{
43	return _imp_acquire_lock_impl(module);
44	}
45
46	PyDoc_STRVAR(_imp_release_lock__doc__,
47	"release_lock($module, /)\n"
48	"--\n"
49	"\n"
50	"Release the interpreter\'s import lock.\n"
51	"\n"
52	"On platforms without threads, this function does nothing.");
53
54	#define _IMP_RELEASE_LOCK_METHODDEF \
55	{"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__},
56
57	static PyObject *
58	_imp_release_lock_impl(PyObject *module);
59
60	static PyObject *
61	_imp_release_lock(PyObject module, PyObject Py_UNUSED(ignored))
62	{
63	return _imp_release_lock_impl(module);
64	}
65
66	PyDoc_STRVAR(_imp__fix_co_filename__doc__,
67	"_fix_co_filename($module, code, path, /)\n"
68	"--\n"
69	"\n"
70	"Changes code.co_filename to specify the passed-in file path.\n"
71	"\n"
72	" code\n"
73	" Code object to change.\n"
74	" path\n"
75	" File path to use.");
76
77	#define _IMP__FIX_CO_FILENAME_METHODDEF \
78	{"_fix_co_filename", _PyCFunction_CAST(_imp__fix_co_filename), METH_FASTCALL, _imp__fix_co_filename__doc__},
79
80	static PyObject *
81	_imp__fix_co_filename_impl(PyObject module, PyCodeObject code,
82	PyObject *path);
83
84	static PyObject *
85	_imp__fix_co_filename(PyObject module, PyObject const *args, Py_ssize_t nargs)
86	{
87	PyObject *return_value = NULL;
88	PyCodeObject *code;
89	PyObject *path;
90
91	if (!_PyArg_CheckPositional("_fix_co_filename", nargs, 2, 2)) {
92	goto exit;
93	}
94	if (!PyObject_TypeCheck(args[0], &PyCode_Type)) { Branch (94:9): [True: 0, False: 4.62k]
95	_PyArg_BadArgument("_fix_co_filename", "argument 1", (&PyCode_Type)->tp_name, args[0]);
96	goto exit;
97	}
98	code = (PyCodeObject *)args[0];
99	if (!PyUnicode_Check(args[1])) { Branch (99:9): [True: 0, False: 4.62k]
100	_PyArg_BadArgument("_fix_co_filename", "argument 2", "str", args[1]);
101	goto exit;
102	}
103	if (PyUnicode_READY(args[1]) == -1) { Branch (103:9): [True: 0, False: 4.62k]
104	goto exit;
105	}
106	path = args[1];
107	return_value = _imp__fix_co_filename_impl(module, code, path);
108
109	exit:
110	return return_value;
111	}
112
113	PyDoc_STRVAR(_imp_create_builtin__doc__,
114	"create_builtin($module, spec, /)\n"
115	"--\n"
116	"\n"
117	"Create an extension module.");
118
119	#define _IMP_CREATE_BUILTIN_METHODDEF \
120	{"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, _imp_create_builtin__doc__},
121
122	PyDoc_STRVAR(_imp_extension_suffixes__doc__,
123	"extension_suffixes($module, /)\n"
124	"--\n"
125	"\n"
126	"Returns the list of file suffixes used to identify extension modules.");
127
128	#define _IMP_EXTENSION_SUFFIXES_METHODDEF \
129	{"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__},
130
131	static PyObject *
132	_imp_extension_suffixes_impl(PyObject *module);
133
134	static PyObject *
135	_imp_extension_suffixes(PyObject module, PyObject Py_UNUSED(ignored))
136	{
137	return _imp_extension_suffixes_impl(module);
138	}
139
140	PyDoc_STRVAR(_imp_init_frozen__doc__,
141	"init_frozen($module, name, /)\n"
142	"--\n"
143	"\n"
144	"Initializes a frozen module.");
145
146	#define _IMP_INIT_FROZEN_METHODDEF \
147	{"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__},
148
149	static PyObject *
150	_imp_init_frozen_impl(PyObject module, PyObject name);
151
152	static PyObject *
153	_imp_init_frozen(PyObject module, PyObject arg)
154	{
155	PyObject *return_value = NULL;
156	PyObject *name;
157
158	if (!PyUnicode_Check(arg)) { Branch (158:9): [True: 0, False: 0]
159	_PyArg_BadArgument("init_frozen", "argument", "str", arg);
160	goto exit;
161	}
162	if (PyUnicode_READY(arg) == -1) { Branch (162:9): [True: 0, False: 0]
163	goto exit;
164	}
165	name = arg;
166	return_value = _imp_init_frozen_impl(module, name);
167
168	exit:
169	return return_value;
170	}
171
172	PyDoc_STRVAR(_imp_find_frozen__doc__,
173	"find_frozen($module, name, /, *, withdata=False)\n"
174	"--\n"
175	"\n"
176	"Return info about the corresponding frozen module (if there is one) or None.\n"
177	"\n"
178	"The returned info (a 2-tuple):\n"
179	"\n"
180	" * data the raw marshalled bytes\n"
181	" * is_package whether or not it is a package\n"
182	" * origname the originally frozen module\'s name, or None if not\n"
183	" a stdlib module (this will usually be the same as\n"
184	" the module\'s current name)");
185
186	#define _IMP_FIND_FROZEN_METHODDEF \
187	{"find_frozen", _PyCFunction_CAST(_imp_find_frozen), METH_FASTCALL\|METH_KEYWORDS, _imp_find_frozen__doc__},
188
189	static PyObject *
190	_imp_find_frozen_impl(PyObject module, PyObject name, int withdata);
191
192	static PyObject *
193	_imp_find_frozen(PyObject module, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
194	{
195	PyObject *return_value = NULL;
196	static const char * const _keywords[] = {"", "withdata", NULL};
197	static _PyArg_Parser _parser = {NULL, _keywords, "find_frozen", 0};
198	PyObject *argsbuf[2];
199	Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE0 (kwnames) : 0) - 1; Branch (199:36): [True: 0, False: 15.3k]
200	PyObject *name;
201	int withdata = 0;
202
203	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
204	if (!args) { Branch (204:9): [True: 0, False: 15.3k]
205	goto exit;
206	}
207	if (!PyUnicode_Check(args[0])) { Branch (207:9): [True: 0, False: 15.3k]
208	_PyArg_BadArgument("find_frozen", "argument 1", "str", args[0]);
209	goto exit;
210	}
211	if (PyUnicode_READY(args[0]) == -1) { Branch (211:9): [True: 0, False: 15.3k]
212	goto exit;
213	}
214	name = args[0];
215	if (!noptargs) { Branch (215:9): [True: 15.3k, False: 0]
216	goto skip_optional_kwonly;
217	}
218	withdata = PyObject_IsTrue(args[1]);
219	if (withdata < 0) { Branch (219:9): [True: 0, False: 0]
220	goto exit;
221	}
222	skip_optional_kwonly:
223	return_value = _imp_find_frozen_impl(module, name, withdata);
224
225	exit:
226	return return_value;
227	}
228
229	PyDoc_STRVAR(_imp_get_frozen_object__doc__,
230	"get_frozen_object($module, name, data=None, /)\n"
231	"--\n"
232	"\n"
233	"Create a code object for a frozen module.");
234
235	#define _IMP_GET_FROZEN_OBJECT_METHODDEF \
236	{"get_frozen_object", _PyCFunction_CAST(_imp_get_frozen_object), METH_FASTCALL, _imp_get_frozen_object__doc__},
237
238	static PyObject *
239	_imp_get_frozen_object_impl(PyObject module, PyObject name,
240	PyObject *dataobj);
241
242	static PyObject *
243	_imp_get_frozen_object(PyObject module, PyObject const *args, Py_ssize_t nargs)
244	{
245	PyObject *return_value = NULL;
246	PyObject *name;
247	PyObject *dataobj = Py_None;
248
249	if (!_PyArg_CheckPositional("get_frozen_object", nargs, 1, 2)) {
250	goto exit;
251	}
252	if (!PyUnicode_Check(args[0])) { Branch (252:9): [True: 0, False: 3.36k]
253	_PyArg_BadArgument("get_frozen_object", "argument 1", "str", args[0]);
254	goto exit;
255	}
256	if (PyUnicode_READY(args[0]) == -1) { Branch (256:9): [True: 0, False: 3.36k]
257	goto exit;
258	}
259	name = args[0];
260	if (nargs < 2) { Branch (260:9): [True: 3.36k, False: 0]
261	goto skip_optional;
262	}
263	dataobj = args[1];
264	skip_optional:
265	return_value = _imp_get_frozen_object_impl(module, name, dataobj);
266
267	exit:
268	return return_value;
269	}
270
271	PyDoc_STRVAR(_imp_is_frozen_package__doc__,
272	"is_frozen_package($module, name, /)\n"
273	"--\n"
274	"\n"
275	"Returns True if the module name is of a frozen package.");
276
277	#define _IMP_IS_FROZEN_PACKAGE_METHODDEF \
278	{"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__},
279
280	static PyObject *
281	_imp_is_frozen_package_impl(PyObject module, PyObject name);
282
283	static PyObject *
284	_imp_is_frozen_package(PyObject module, PyObject arg)
285	{
286	PyObject *return_value = NULL;
287	PyObject *name;
288
289	if (!PyUnicode_Check(arg)) { Branch (289:9): [True: 0, False: 318]
290	_PyArg_BadArgument("is_frozen_package", "argument", "str", arg);
291	goto exit;
292	}
293	if (PyUnicode_READY(arg) == -1) { Branch (293:9): [True: 0, False: 318]
294	goto exit;
295	}
296	name = arg;
297	return_value = _imp_is_frozen_package_impl(module, name);
298
299	exit:
300	return return_value;
301	}
302
303	PyDoc_STRVAR(_imp_is_builtin__doc__,
304	"is_builtin($module, name, /)\n"
305	"--\n"
306	"\n"
307	"Returns True if the module name corresponds to a built-in module.");
308
309	#define _IMP_IS_BUILTIN_METHODDEF \
310	{"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__},
311
312	static PyObject *
313	_imp_is_builtin_impl(PyObject module, PyObject name);
314
315	static PyObject *
316	_imp_is_builtin(PyObject module, PyObject arg)
317	{
318	PyObject *return_value = NULL;
319	PyObject *name;
320
321	if (!PyUnicode_Check(arg)) { Branch (321:9): [True: 0, False: 15.5k]
322	_PyArg_BadArgument("is_builtin", "argument", "str", arg);
323	goto exit;
324	}
325	if (PyUnicode_READY(arg) == -1) { Branch (325:9): [True: 0, False: 15.5k]
326	goto exit;
327	}
328	name = arg;
329	return_value = _imp_is_builtin_impl(module, name);
330
331	exit:
332	return return_value;
333	}
334
335	PyDoc_STRVAR(_imp_is_frozen__doc__,
336	"is_frozen($module, name, /)\n"
337	"--\n"
338	"\n"
339	"Returns True if the module name corresponds to a frozen module.");
340
341	#define _IMP_IS_FROZEN_METHODDEF \
342	{"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__},
343
344	static PyObject *
345	_imp_is_frozen_impl(PyObject module, PyObject name);
346
347	static PyObject *
348	_imp_is_frozen(PyObject module, PyObject arg)
349	{
350	PyObject *return_value = NULL;
351	PyObject *name;
352
353	if (!PyUnicode_Check(arg)) { Branch (353:9): [True: 0, False: 45.1k]
354	_PyArg_BadArgument("is_frozen", "argument", "str", arg);
355	goto exit;
356	}
357	if (PyUnicode_READY(arg) == -1) { Branch (357:9): [True: 0, False: 45.1k]
358	goto exit;
359	}
360	name = arg;
361	return_value = _imp_is_frozen_impl(module, name);
362
363	exit:
364	return return_value;
365	}
366
367	PyDoc_STRVAR(_imp__frozen_module_names__doc__,
368	"_frozen_module_names($module, /)\n"
369	"--\n"
370	"\n"
371	"Returns the list of available frozen modules.");
372
373	#define _IMP__FROZEN_MODULE_NAMES_METHODDEF \
374	{"_frozen_module_names", (PyCFunction)_imp__frozen_module_names, METH_NOARGS, _imp__frozen_module_names__doc__},
375
376	static PyObject *
377	_imp__frozen_module_names_impl(PyObject *module);
378
379	static PyObject *
380	_imp__frozen_module_names(PyObject module, PyObject Py_UNUSED(ignored))
381	{
382	return _imp__frozen_module_names_impl(module);
383	}
384
385	PyDoc_STRVAR(_imp__override_frozen_modules_for_tests__doc__,
386	"_override_frozen_modules_for_tests($module, override, /)\n"
387	"--\n"
388	"\n"
389	"(internal-only) Override PyConfig.use_frozen_modules.\n"
390	"\n"
391	"(-1: \"off\", 1: \"on\", 0: no override)\n"
392	"See frozen_modules() in Lib/test/support/import_helper.py.");
393
394	#define _IMP__OVERRIDE_FROZEN_MODULES_FOR_TESTS_METHODDEF \
395	{"_override_frozen_modules_for_tests", (PyCFunction)_imp__override_frozen_modules_for_tests, METH_O, _imp__override_frozen_modules_for_tests__doc__},
396
397	static PyObject *
398	_imp__override_frozen_modules_for_tests_impl(PyObject *module, int override);
399
400	static PyObject *
401	_imp__override_frozen_modules_for_tests(PyObject module, PyObject arg)
402	{
403	PyObject *return_value = NULL;
404	int override;
405
406	override = _PyLong_AsInt(arg);
407	if (override == -1 && PyErr_Occurred()191 ) { Branch (407:9): [True: 191, False: 553] Branch (407:27): [True: 0, False: 191]
408	goto exit;
409	}
410	return_value = _imp__override_frozen_modules_for_tests_impl(module, override);
411
412	exit:
413	return return_value;
414	}
415
416	#if defined(HAVE_DYNAMIC_LOADING)
417
418	PyDoc_STRVAR(_imp_create_dynamic__doc__,
419	"create_dynamic($module, spec, file=<unrepresentable>, /)\n"
420	"--\n"
421	"\n"
422	"Create an extension module.");
423
424	#define _IMP_CREATE_DYNAMIC_METHODDEF \
425	{"create_dynamic", _PyCFunction_CAST(_imp_create_dynamic), METH_FASTCALL, _imp_create_dynamic__doc__},
426
427	static PyObject *
428	_imp_create_dynamic_impl(PyObject module, PyObject spec, PyObject *file);
429
430	static PyObject *
431	_imp_create_dynamic(PyObject module, PyObject const *args, Py_ssize_t nargs)
432	{
433	PyObject *return_value = NULL;
434	PyObject *spec;
435	PyObject *file = NULL;
436
437	if (!_PyArg_CheckPositional("create_dynamic", nargs, 1, 2)) {
438	goto exit;
439	}
440	spec = args[0];
441	if (nargs < 2) { Branch (441:9): [True: 362, False: 0]
442	goto skip_optional;
443	}
444	file = args[1];
445	skip_optional:
446	return_value = _imp_create_dynamic_impl(module, spec, file);
447
448	exit:
449	return return_value;
450	}
451
452	#endif /* defined(HAVE_DYNAMIC_LOADING) */
453
454	#if defined(HAVE_DYNAMIC_LOADING)
455
456	PyDoc_STRVAR(_imp_exec_dynamic__doc__,
457	"exec_dynamic($module, mod, /)\n"
458	"--\n"
459	"\n"
460	"Initialize an extension module.");
461
462	#define _IMP_EXEC_DYNAMIC_METHODDEF \
463	{"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, _imp_exec_dynamic__doc__},
464
465	static int
466	_imp_exec_dynamic_impl(PyObject module, PyObject mod);
467
468	static PyObject *
469	_imp_exec_dynamic(PyObject module, PyObject mod)
470	{
471	PyObject *return_value = NULL;
472	int _return_value;
473
474	_return_value = _imp_exec_dynamic_impl(module, mod);
475	if ((_return_value == -1) && PyErr_Occurred()6 ) { Branch (475:9): [True: 6, False: 330] Branch (475:34): [True: 6, False: 0]
476	goto exit;
477	}
478	return_value = PyLong_FromLong((long)_return_value);
479
480	exit:
481	return return_value;
482	}
483
484	#endif /* defined(HAVE_DYNAMIC_LOADING) */
485
486	PyDoc_STRVAR(_imp_exec_builtin__doc__,
487	"exec_builtin($module, mod, /)\n"
488	"--\n"
489	"\n"
490	"Initialize a built-in module.");
491
492	#define _IMP_EXEC_BUILTIN_METHODDEF \
493	{"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, _imp_exec_builtin__doc__},
494
495	static int
496	_imp_exec_builtin_impl(PyObject module, PyObject mod);
497
498	static PyObject *
499	_imp_exec_builtin(PyObject module, PyObject mod)
500	{
501	PyObject *return_value = NULL;
502	int _return_value;
503
504	_return_value = _imp_exec_builtin_impl(module, mod);
505	if ((_return_value == -1) && PyErr_Occurred()0 ) { Branch (505:9): [True: 0, False: 3.37k] Branch (505:34): [True: 0, False: 0]
506	goto exit;
507	}
508	return_value = PyLong_FromLong((long)_return_value);
509
510	exit:
511	return return_value;
512	}
513
514	PyDoc_STRVAR(_imp_source_hash__doc__,
515	"source_hash($module, /, key, source)\n"
516	"--\n"
517	"\n");
518
519	#define _IMP_SOURCE_HASH_METHODDEF \
520	{"source_hash", _PyCFunction_CAST(_imp_source_hash), METH_FASTCALL\|METH_KEYWORDS, _imp_source_hash__doc__},
521
522	static PyObject *
523	_imp_source_hash_impl(PyObject module, long key, Py_buffer source);
524
525	static PyObject *
526	_imp_source_hash(PyObject module, PyObject const args, Py_ssize_t nargs, PyObject kwnames)
527	{
528	PyObject *return_value = NULL;
529	static const char * const _keywords[] = {"key", "source", NULL};
530	static _PyArg_Parser _parser = {NULL, _keywords, "source_hash", 0};
531	PyObject *argsbuf[2];
532	long key;
533	Py_buffer source = {NULL, NULL};
534
535	args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
536	if (!args) { Branch (536:9): [True: 0, False: 173]
537	goto exit;
538	}
539	key = PyLong_AsLong(args[0]);
540	if (key == -1 && PyErr_Occurred()0 ) { Branch (540:9): [True: 0, False: 173] Branch (540:22): [True: 0, False: 0]
541	goto exit;
542	}
543	if (PyObject_GetBuffer(args[1], &source, PyBUF_SIMPLE) != 0) { Branch (543:9): [True: 0, False: 173]
544	goto exit;
545	}
546	if (!PyBuffer_IsContiguous(&source, 'C')) { Branch (546:9): [True: 0, False: 173]
547	_PyArg_BadArgument("source_hash", "argument 'source'", "contiguous buffer", args[1]);
548	goto exit;
549	}
550	return_value = _imp_source_hash_impl(module, key, &source);
551
552	exit:
553	/* Cleanup for source */
554	if (source.obj) { Branch (554:9): [True: 173, False: 0]
555	PyBuffer_Release(&source);
556	}
557
558	return return_value;
559	}
560
561	#ifndef _IMP_CREATE_DYNAMIC_METHODDEF
562	#define _IMP_CREATE_DYNAMIC_METHODDEF
563	#endif /* !defined(_IMP_CREATE_DYNAMIC_METHODDEF) */
564
565	#ifndef _IMP_EXEC_DYNAMIC_METHODDEF
566	#define _IMP_EXEC_DYNAMIC_METHODDEF
567	#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
568	/[clinic end generated code: output=8d0f4305b1d0714b input=a9049054013a1b77]/