Branch data 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 : 1448622 : _imp_acquire_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
42 : : {
43 : 1448622 : 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 : 1448623 : _imp_release_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
62 : : {
63 : 1448623 : 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 : 163173 : _imp__fix_co_filename(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
86 : : {
87 : 163173 : PyObject *return_value = NULL;
88 : : PyCodeObject *code;
89 : : PyObject *path;
90 : :
91 [ + - - + : 163173 : if (!_PyArg_CheckPositional("_fix_co_filename", nargs, 2, 2)) {
- - ]
92 : 0 : goto exit;
93 : : }
94 [ - + ]: 163173 : 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 : 163173 : code = (PyCodeObject *)args[0];
99 [ - + ]: 163173 : if (!PyUnicode_Check(args[1])) {
100 : 0 : _PyArg_BadArgument("_fix_co_filename", "argument 2", "str", args[1]);
101 : 0 : goto exit;
102 : : }
103 [ - + ]: 163173 : if (PyUnicode_READY(args[1]) == -1) {
104 : 0 : goto exit;
105 : : }
106 : 163173 : path = args[1];
107 : 163173 : return_value = _imp__fix_co_filename_impl(module, code, path);
108 : :
109 : 163173 : exit:
110 : 163173 : 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 : 6395 : _imp_extension_suffixes(PyObject *module, PyObject *Py_UNUSED(ignored))
136 : : {
137 : 6395 : 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 : 255491 : _imp_find_frozen(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
194 : : {
195 : 255491 : 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 [ - + ]: 255491 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
200 : : PyObject *name;
201 : 255491 : int withdata = 0;
202 : :
203 [ + - + - : 255491 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
204 [ - + ]: 255491 : if (!args) {
205 : 0 : goto exit;
206 : : }
207 [ - + ]: 255491 : if (!PyUnicode_Check(args[0])) {
208 : 0 : _PyArg_BadArgument("find_frozen", "argument 1", "str", args[0]);
209 : 0 : goto exit;
210 : : }
211 [ - + ]: 255491 : if (PyUnicode_READY(args[0]) == -1) {
212 : 0 : goto exit;
213 : : }
214 : 255491 : name = args[0];
215 [ + - ]: 255491 : if (!noptargs) {
216 : 255491 : 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 : 255491 : return_value = _imp_find_frozen_impl(module, name, withdata);
224 : :
225 : 255491 : exit:
226 : 255491 : 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 : 42404 : _imp_get_frozen_object(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
244 : : {
245 : 42404 : PyObject *return_value = NULL;
246 : : PyObject *name;
247 : 42404 : PyObject *dataobj = Py_None;
248 : :
249 [ + - - + : 42404 : if (!_PyArg_CheckPositional("get_frozen_object", nargs, 1, 2)) {
- - ]
250 : 0 : goto exit;
251 : : }
252 [ - + ]: 42404 : if (!PyUnicode_Check(args[0])) {
253 : 0 : _PyArg_BadArgument("get_frozen_object", "argument 1", "str", args[0]);
254 : 0 : goto exit;
255 : : }
256 [ - + ]: 42404 : if (PyUnicode_READY(args[0]) == -1) {
257 : 0 : goto exit;
258 : : }
259 : 42404 : name = args[0];
260 [ + - ]: 42404 : if (nargs < 2) {
261 : 42404 : goto skip_optional;
262 : : }
263 : 0 : dataobj = args[1];
264 : 42404 : skip_optional:
265 : 42404 : return_value = _imp_get_frozen_object_impl(module, name, dataobj);
266 : :
267 : 42404 : exit:
268 : 42404 : 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 : 3174 : _imp_is_frozen_package(PyObject *module, PyObject *arg)
285 : : {
286 : 3174 : PyObject *return_value = NULL;
287 : : PyObject *name;
288 : :
289 [ - + ]: 3174 : if (!PyUnicode_Check(arg)) {
290 : 0 : _PyArg_BadArgument("is_frozen_package", "argument", "str", arg);
291 : 0 : goto exit;
292 : : }
293 [ - + ]: 3174 : if (PyUnicode_READY(arg) == -1) {
294 : 0 : goto exit;
295 : : }
296 : 3174 : name = arg;
297 : 3174 : return_value = _imp_is_frozen_package_impl(module, name);
298 : :
299 : 3174 : exit:
300 : 3174 : 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 : 231304 : _imp_is_builtin(PyObject *module, PyObject *arg)
317 : : {
318 : 231304 : PyObject *return_value = NULL;
319 : : PyObject *name;
320 : :
321 [ - + ]: 231304 : if (!PyUnicode_Check(arg)) {
322 : 0 : _PyArg_BadArgument("is_builtin", "argument", "str", arg);
323 : 0 : goto exit;
324 : : }
325 [ - + ]: 231304 : if (PyUnicode_READY(arg) == -1) {
326 : 0 : goto exit;
327 : : }
328 : 231304 : name = arg;
329 : 231304 : return_value = _imp_is_builtin_impl(module, name);
330 : :
331 : 231304 : exit:
332 : 231304 : 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 : 11437 : _imp_is_frozen(PyObject *module, PyObject *arg)
349 : : {
350 : 11437 : PyObject *return_value = NULL;
351 : : PyObject *name;
352 : :
353 [ - + ]: 11437 : if (!PyUnicode_Check(arg)) {
354 : 0 : _PyArg_BadArgument("is_frozen", "argument", "str", arg);
355 : 0 : goto exit;
356 : : }
357 [ - + ]: 11437 : if (PyUnicode_READY(arg) == -1) {
358 : 0 : goto exit;
359 : : }
360 : 11437 : name = arg;
361 : 11437 : return_value = _imp_is_frozen_impl(module, name);
362 : :
363 : 11437 : exit:
364 : 11437 : 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 : 29262 : _imp_create_dynamic(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
432 : : {
433 : 29262 : PyObject *return_value = NULL;
434 : : PyObject *spec;
435 : 29262 : PyObject *file = NULL;
436 : :
437 [ + - - + : 29262 : if (!_PyArg_CheckPositional("create_dynamic", nargs, 1, 2)) {
- - ]
438 : 0 : goto exit;
439 : : }
440 : 29262 : spec = args[0];
441 [ + - ]: 29262 : if (nargs < 2) {
442 : 29262 : goto skip_optional;
443 : : }
444 : 0 : file = args[1];
445 : 29262 : skip_optional:
446 : 29262 : return_value = _imp_create_dynamic_impl(module, spec, file);
447 : :
448 : 29262 : exit:
449 : 29262 : 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 : 29236 : _imp_exec_dynamic(PyObject *module, PyObject *mod)
470 : : {
471 : 29236 : PyObject *return_value = NULL;
472 : : int _return_value;
473 : :
474 : 29236 : _return_value = _imp_exec_dynamic_impl(module, mod);
475 [ + + + - ]: 29236 : if ((_return_value == -1) && PyErr_Occurred()) {
476 : 6 : goto exit;
477 : : }
478 : 29230 : return_value = PyLong_FromLong((long)_return_value);
479 : :
480 : 29236 : exit:
481 : 29236 : 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 : 53608 : _imp_exec_builtin(PyObject *module, PyObject *mod)
500 : : {
501 : 53608 : PyObject *return_value = NULL;
502 : : int _return_value;
503 : :
504 : 53608 : _return_value = _imp_exec_builtin_impl(module, mod);
505 [ - + - - ]: 53608 : if ((_return_value == -1) && PyErr_Occurred()) {
506 : 0 : goto exit;
507 : : }
508 : 53608 : return_value = PyLong_FromLong((long)_return_value);
509 : :
510 : 53608 : exit:
511 : 53608 : 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 : 692 : _imp_source_hash(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
527 : : {
528 : 692 : 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 : 692 : Py_buffer source = {NULL, NULL};
534 : :
535 [ + - + - : 692 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ - - + ]
536 [ - + ]: 692 : if (!args) {
537 : 0 : goto exit;
538 : : }
539 : 692 : key = PyLong_AsLong(args[0]);
540 [ - + - - ]: 692 : if (key == -1 && PyErr_Occurred()) {
541 : 0 : goto exit;
542 : : }
543 [ - + ]: 692 : if (PyObject_GetBuffer(args[1], &source, PyBUF_SIMPLE) != 0) {
544 : 0 : goto exit;
545 : : }
546 [ - + ]: 692 : if (!PyBuffer_IsContiguous(&source, 'C')) {
547 : 0 : _PyArg_BadArgument("source_hash", "argument 'source'", "contiguous buffer", args[1]);
548 : 0 : goto exit;
549 : : }
550 : 692 : return_value = _imp_source_hash_impl(module, key, &source);
551 : :
552 : 692 : exit:
553 : : /* Cleanup for source */
554 [ + - ]: 692 : if (source.obj) {
555 : 692 : PyBuffer_Release(&source);
556 : : }
557 : :
558 : 692 : 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]*/
|
