Debian Codegraph @

Python/clinic/import.c.h

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