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