Line data Source code
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 71 : _imp_lock_held(PyObject *module, PyObject *Py_UNUSED(ignored))
21 : {
22 71 : 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 1498360 : _imp_acquire_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
42 : {
43 1498360 : 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 1498360 : _imp_release_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
62 : {
63 1498360 : 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 201625 : _imp__fix_co_filename(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
86 : {
87 201625 : PyObject *return_value = NULL;
88 : PyCodeObject *code;
89 : PyObject *path;
90 :
91 201625 : if (!_PyArg_CheckPositional("_fix_co_filename", nargs, 2, 2)) {
92 0 : goto exit;
93 : }
94 201625 : if (!PyObject_TypeCheck(args[0], &PyCode_Type)) {
95 0 : _PyArg_BadArgument("_fix_co_filename", "argument 1", (&PyCode_Type)->tp_name, args[0]);
96 0 : goto exit;
97 : }
98 201625 : code = (PyCodeObject *)args[0];
99 201625 : if (!PyUnicode_Check(args[1])) {
100 0 : _PyArg_BadArgument("_fix_co_filename", "argument 2", "str", args[1]);
101 0 : goto exit;
102 : }
103 201625 : if (PyUnicode_READY(args[1]) == -1) {
104 0 : goto exit;
105 : }
106 201625 : path = args[1];
107 201625 : return_value = _imp__fix_co_filename_impl(module, code, path);
108 :
109 201625 : exit:
110 201625 : 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 6387 : _imp_extension_suffixes(PyObject *module, PyObject *Py_UNUSED(ignored))
136 : {
137 6387 : 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 0 : _imp_init_frozen(PyObject *module, PyObject *arg)
154 : {
155 0 : PyObject *return_value = NULL;
156 : PyObject *name;
157 :
158 0 : if (!PyUnicode_Check(arg)) {
159 0 : _PyArg_BadArgument("init_frozen", "argument", "str", arg);
160 0 : goto exit;
161 : }
162 0 : if (PyUnicode_READY(arg) == -1) {
163 0 : goto exit;
164 : }
165 0 : name = arg;
166 0 : return_value = _imp_init_frozen_impl(module, name);
167 :
168 0 : exit:
169 0 : 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 258254 : _imp_find_frozen(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
194 : {
195 258254 : 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 258254 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
200 : PyObject *name;
201 258254 : int withdata = 0;
202 :
203 258254 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
204 258254 : if (!args) {
205 0 : goto exit;
206 : }
207 258254 : if (!PyUnicode_Check(args[0])) {
208 0 : _PyArg_BadArgument("find_frozen", "argument 1", "str", args[0]);
209 0 : goto exit;
210 : }
211 258254 : if (PyUnicode_READY(args[0]) == -1) {
212 0 : goto exit;
213 : }
214 258254 : name = args[0];
215 258254 : if (!noptargs) {
216 258254 : goto skip_optional_kwonly;
217 : }
218 0 : withdata = PyObject_IsTrue(args[1]);
219 0 : if (withdata < 0) {
220 0 : goto exit;
221 : }
222 0 : skip_optional_kwonly:
223 258254 : return_value = _imp_find_frozen_impl(module, name, withdata);
224 :
225 258254 : exit:
226 258254 : 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 6356 : _imp_get_frozen_object(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
244 : {
245 6356 : PyObject *return_value = NULL;
246 : PyObject *name;
247 6356 : PyObject *dataobj = Py_None;
248 :
249 6356 : if (!_PyArg_CheckPositional("get_frozen_object", nargs, 1, 2)) {
250 0 : goto exit;
251 : }
252 6356 : if (!PyUnicode_Check(args[0])) {
253 0 : _PyArg_BadArgument("get_frozen_object", "argument 1", "str", args[0]);
254 0 : goto exit;
255 : }
256 6356 : if (PyUnicode_READY(args[0]) == -1) {
257 0 : goto exit;
258 : }
259 6356 : name = args[0];
260 6356 : if (nargs < 2) {
261 6356 : goto skip_optional;
262 : }
263 0 : dataobj = args[1];
264 6356 : skip_optional:
265 6356 : return_value = _imp_get_frozen_object_impl(module, name, dataobj);
266 :
267 6356 : exit:
268 6356 : 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 3170 : _imp_is_frozen_package(PyObject *module, PyObject *arg)
285 : {
286 3170 : PyObject *return_value = NULL;
287 : PyObject *name;
288 :
289 3170 : if (!PyUnicode_Check(arg)) {
290 0 : _PyArg_BadArgument("is_frozen_package", "argument", "str", arg);
291 0 : goto exit;
292 : }
293 3170 : if (PyUnicode_READY(arg) == -1) {
294 0 : goto exit;
295 : }
296 3170 : name = arg;
297 3170 : return_value = _imp_is_frozen_package_impl(module, name);
298 :
299 3170 : exit:
300 3170 : 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 232387 : _imp_is_builtin(PyObject *module, PyObject *arg)
317 : {
318 232387 : PyObject *return_value = NULL;
319 : PyObject *name;
320 :
321 232387 : if (!PyUnicode_Check(arg)) {
322 0 : _PyArg_BadArgument("is_builtin", "argument", "str", arg);
323 0 : goto exit;
324 : }
325 232387 : if (PyUnicode_READY(arg) == -1) {
326 0 : goto exit;
327 : }
328 232387 : name = arg;
329 232387 : return_value = _imp_is_builtin_impl(module, name);
330 :
331 232387 : exit:
332 232387 : 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 11463 : _imp_is_frozen(PyObject *module, PyObject *arg)
349 : {
350 11463 : PyObject *return_value = NULL;
351 : PyObject *name;
352 :
353 11463 : if (!PyUnicode_Check(arg)) {
354 0 : _PyArg_BadArgument("is_frozen", "argument", "str", arg);
355 0 : goto exit;
356 : }
357 11463 : if (PyUnicode_READY(arg) == -1) {
358 0 : goto exit;
359 : }
360 11463 : name = arg;
361 11463 : return_value = _imp_is_frozen_impl(module, name);
362 :
363 11463 : exit:
364 11463 : 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 1 : _imp__frozen_module_names(PyObject *module, PyObject *Py_UNUSED(ignored))
381 : {
382 1 : 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 772 : _imp__override_frozen_modules_for_tests(PyObject *module, PyObject *arg)
402 : {
403 772 : PyObject *return_value = NULL;
404 : int override;
405 :
406 772 : override = _PyLong_AsInt(arg);
407 772 : if (override == -1 && PyErr_Occurred()) {
408 0 : goto exit;
409 : }
410 772 : return_value = _imp__override_frozen_modules_for_tests_impl(module, override);
411 :
412 772 : exit:
413 772 : 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 29466 : _imp_create_dynamic(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
432 : {
433 29466 : PyObject *return_value = NULL;
434 : PyObject *spec;
435 29466 : PyObject *file = NULL;
436 :
437 29466 : if (!_PyArg_CheckPositional("create_dynamic", nargs, 1, 2)) {
438 0 : goto exit;
439 : }
440 29466 : spec = args[0];
441 29466 : if (nargs < 2) {
442 29466 : goto skip_optional;
443 : }
444 0 : file = args[1];
445 29466 : skip_optional:
446 29466 : return_value = _imp_create_dynamic_impl(module, spec, file);
447 :
448 29466 : exit:
449 29466 : 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 29394 : _imp_exec_dynamic(PyObject *module, PyObject *mod)
470 : {
471 29394 : PyObject *return_value = NULL;
472 : int _return_value;
473 :
474 29394 : _return_value = _imp_exec_dynamic_impl(module, mod);
475 29394 : if ((_return_value == -1) && PyErr_Occurred()) {
476 6 : goto exit;
477 : }
478 29388 : return_value = PyLong_FromLong((long)_return_value);
479 :
480 29394 : exit:
481 29394 : 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 53678 : _imp_exec_builtin(PyObject *module, PyObject *mod)
500 : {
501 53678 : PyObject *return_value = NULL;
502 : int _return_value;
503 :
504 53678 : _return_value = _imp_exec_builtin_impl(module, mod);
505 53678 : if ((_return_value == -1) && PyErr_Occurred()) {
506 0 : goto exit;
507 : }
508 53678 : return_value = PyLong_FromLong((long)_return_value);
509 :
510 53678 : exit:
511 53678 : 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 665 : _imp_source_hash(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
527 : {
528 665 : 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 665 : Py_buffer source = {NULL, NULL};
534 :
535 665 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
536 665 : if (!args) {
537 0 : goto exit;
538 : }
539 665 : key = PyLong_AsLong(args[0]);
540 665 : if (key == -1 && PyErr_Occurred()) {
541 0 : goto exit;
542 : }
543 665 : if (PyObject_GetBuffer(args[1], &source, PyBUF_SIMPLE) != 0) {
544 0 : goto exit;
545 : }
546 665 : if (!PyBuffer_IsContiguous(&source, 'C')) {
547 0 : _PyArg_BadArgument("source_hash", "argument 'source'", "contiguous buffer", args[1]);
548 0 : goto exit;
549 : }
550 665 : return_value = _imp_source_hash_impl(module, key, &source);
551 :
552 665 : exit:
553 : /* Cleanup for source */
554 665 : if (source.obj) {
555 665 : PyBuffer_Release(&source);
556 : }
557 :
558 665 : 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]*/
|
