Branch data Line data Source code
1 : : /*
2 : : * C Extension module to test Python internal C APIs (Include/internal).
3 : : */
4 : :
5 : : #ifndef Py_BUILD_CORE_BUILTIN
6 : : # define Py_BUILD_CORE_MODULE 1
7 : : #endif
8 : :
9 : : /* Always enable assertions */
10 : : #undef NDEBUG
11 : :
12 : : #define PY_SSIZE_T_CLEAN
13 : :
14 : : #include "Python.h"
15 : : #include "pycore_atomic_funcs.h" // _Py_atomic_int_get()
16 : : #include "pycore_bitutils.h" // _Py_bswap32()
17 : : #include "pycore_compile.h" // _PyCompile_CodeGen, _PyCompile_OptimizeCfg
18 : : #include "pycore_fileutils.h" // _Py_normpath
19 : : #include "pycore_frame.h" // _PyInterpreterFrame
20 : : #include "pycore_gc.h" // PyGC_Head
21 : : #include "pycore_hashtable.h" // _Py_hashtable_new()
22 : : #include "pycore_initconfig.h" // _Py_GetConfigsAsDict()
23 : : #include "pycore_pathconfig.h" // _PyPathConfig_ClearGlobal()
24 : : #include "pycore_interp.h" // _PyInterpreterState_GetConfigCopy()
25 : : #include "pycore_pyerrors.h" // _Py_UTF8_Edit_Cost()
26 : : #include "pycore_pystate.h" // _PyThreadState_GET()
27 : : #include "osdefs.h" // MAXPATHLEN
28 : :
29 : : #include "clinic/_testinternalcapi.c.h"
30 : :
31 : :
32 : : #define MODULE_NAME "_testinternalcapi"
33 : :
34 : :
35 : : static PyObject *
36 : 0 : _get_current_module(void)
37 : : {
38 : : // We ensured it was imported in _run_script().
39 : 0 : PyObject *name = PyUnicode_FromString(MODULE_NAME);
40 [ # # ]: 0 : if (name == NULL) {
41 : 0 : return NULL;
42 : : }
43 : 0 : PyObject *mod = PyImport_GetModule(name);
44 : 0 : Py_DECREF(name);
45 [ # # ]: 0 : if (mod == NULL) {
46 : 0 : return NULL;
47 : : }
48 [ # # ]: 0 : assert(mod != Py_None);
49 : 0 : return mod;
50 : : }
51 : :
52 : :
53 : : /* module state *************************************************************/
54 : :
55 : : typedef struct {
56 : : PyObject *record_list;
57 : : } module_state;
58 : :
59 : : static inline module_state *
60 : 8 : get_module_state(PyObject *mod)
61 : : {
62 [ - + ]: 8 : assert(mod != NULL);
63 : 8 : module_state *state = PyModule_GetState(mod);
64 [ - + ]: 8 : assert(state != NULL);
65 : 8 : return state;
66 : : }
67 : :
68 : : static int
69 : 6 : traverse_module_state(module_state *state, visitproc visit, void *arg)
70 : : {
71 [ - + - - ]: 6 : Py_VISIT(state->record_list);
72 : 6 : return 0;
73 : : }
74 : :
75 : : static int
76 : 2 : clear_module_state(module_state *state)
77 : : {
78 [ - + ]: 2 : Py_CLEAR(state->record_list);
79 : 2 : return 0;
80 : : }
81 : :
82 : :
83 : : /* module functions *********************************************************/
84 : :
85 : : /*[clinic input]
86 : : module _testinternalcapi
87 : : [clinic start generated code]*/
88 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7bb583d8c9eb9a78]*/
89 : : static PyObject *
90 : 0 : get_configs(PyObject *self, PyObject *Py_UNUSED(args))
91 : : {
92 : 0 : return _Py_GetConfigsAsDict();
93 : : }
94 : :
95 : :
96 : : static PyObject*
97 : 0 : get_recursion_depth(PyObject *self, PyObject *Py_UNUSED(args))
98 : : {
99 : 0 : PyThreadState *tstate = _PyThreadState_GET();
100 : :
101 : 0 : return PyLong_FromLong(tstate->py_recursion_limit - tstate->py_recursion_remaining);
102 : : }
103 : :
104 : :
105 : : static PyObject*
106 : 0 : test_bswap(PyObject *self, PyObject *Py_UNUSED(args))
107 : : {
108 : 0 : uint16_t u16 = _Py_bswap16(UINT16_C(0x3412));
109 [ # # ]: 0 : if (u16 != UINT16_C(0x1234)) {
110 : 0 : PyErr_Format(PyExc_AssertionError,
111 : : "_Py_bswap16(0x3412) returns %u", u16);
112 : 0 : return NULL;
113 : : }
114 : :
115 : 0 : uint32_t u32 = _Py_bswap32(UINT32_C(0x78563412));
116 [ # # ]: 0 : if (u32 != UINT32_C(0x12345678)) {
117 : 0 : PyErr_Format(PyExc_AssertionError,
118 : : "_Py_bswap32(0x78563412) returns %lu", u32);
119 : 0 : return NULL;
120 : : }
121 : :
122 : 0 : uint64_t u64 = _Py_bswap64(UINT64_C(0xEFCDAB9078563412));
123 [ # # ]: 0 : if (u64 != UINT64_C(0x1234567890ABCDEF)) {
124 : 0 : PyErr_Format(PyExc_AssertionError,
125 : : "_Py_bswap64(0xEFCDAB9078563412) returns %llu", u64);
126 : 0 : return NULL;
127 : : }
128 : :
129 : 0 : Py_RETURN_NONE;
130 : : }
131 : :
132 : :
133 : : static int
134 : 0 : check_popcount(uint32_t x, int expected)
135 : : {
136 : : // Use volatile to prevent the compiler to optimize out the whole test
137 : 0 : volatile uint32_t u = x;
138 : 0 : int bits = _Py_popcount32(u);
139 [ # # ]: 0 : if (bits != expected) {
140 : 0 : PyErr_Format(PyExc_AssertionError,
141 : : "_Py_popcount32(%lu) returns %i, expected %i",
142 : : (unsigned long)x, bits, expected);
143 : 0 : return -1;
144 : : }
145 : 0 : return 0;
146 : : }
147 : :
148 : :
149 : : static PyObject*
150 : 0 : test_popcount(PyObject *self, PyObject *Py_UNUSED(args))
151 : : {
152 : : #define CHECK(X, RESULT) \
153 : : do { \
154 : : if (check_popcount(X, RESULT) < 0) { \
155 : : return NULL; \
156 : : } \
157 : : } while (0)
158 : :
159 [ # # ]: 0 : CHECK(0, 0);
160 [ # # ]: 0 : CHECK(1, 1);
161 [ # # ]: 0 : CHECK(0x08080808, 4);
162 [ # # ]: 0 : CHECK(0x10000001, 2);
163 [ # # ]: 0 : CHECK(0x10101010, 4);
164 [ # # ]: 0 : CHECK(0x10204080, 4);
165 [ # # ]: 0 : CHECK(0xDEADCAFE, 22);
166 [ # # ]: 0 : CHECK(0xFFFFFFFF, 32);
167 : 0 : Py_RETURN_NONE;
168 : :
169 : : #undef CHECK
170 : : }
171 : :
172 : :
173 : : static int
174 : 0 : check_bit_length(unsigned long x, int expected)
175 : : {
176 : : // Use volatile to prevent the compiler to optimize out the whole test
177 : 0 : volatile unsigned long u = x;
178 : 0 : int len = _Py_bit_length(u);
179 [ # # ]: 0 : if (len != expected) {
180 : 0 : PyErr_Format(PyExc_AssertionError,
181 : : "_Py_bit_length(%lu) returns %i, expected %i",
182 : : x, len, expected);
183 : 0 : return -1;
184 : : }
185 : 0 : return 0;
186 : : }
187 : :
188 : :
189 : : static PyObject*
190 : 0 : test_bit_length(PyObject *self, PyObject *Py_UNUSED(args))
191 : : {
192 : : #define CHECK(X, RESULT) \
193 : : do { \
194 : : if (check_bit_length(X, RESULT) < 0) { \
195 : : return NULL; \
196 : : } \
197 : : } while (0)
198 : :
199 [ # # ]: 0 : CHECK(0, 0);
200 [ # # ]: 0 : CHECK(1, 1);
201 [ # # ]: 0 : CHECK(0x1000, 13);
202 [ # # ]: 0 : CHECK(0x1234, 13);
203 [ # # ]: 0 : CHECK(0x54321, 19);
204 [ # # ]: 0 : CHECK(0x7FFFFFFF, 31);
205 [ # # ]: 0 : CHECK(0xFFFFFFFF, 32);
206 : 0 : Py_RETURN_NONE;
207 : :
208 : : #undef CHECK
209 : : }
210 : :
211 : :
212 : : #define TO_PTR(ch) ((void*)(uintptr_t)ch)
213 : : #define FROM_PTR(ptr) ((uintptr_t)ptr)
214 : : #define VALUE(key) (1 + ((int)(key) - 'a'))
215 : :
216 : : static Py_uhash_t
217 : 0 : hash_char(const void *key)
218 : : {
219 : 0 : char ch = (char)FROM_PTR(key);
220 : 0 : return ch;
221 : : }
222 : :
223 : :
224 : : static int
225 : 0 : hashtable_cb(_Py_hashtable_t *table,
226 : : const void *key_ptr, const void *value_ptr,
227 : : void *user_data)
228 : : {
229 : 0 : int *count = (int *)user_data;
230 : 0 : char key = (char)FROM_PTR(key_ptr);
231 : 0 : int value = (int)FROM_PTR(value_ptr);
232 [ # # ]: 0 : assert(value == VALUE(key));
233 : 0 : *count += 1;
234 : 0 : return 0;
235 : : }
236 : :
237 : :
238 : : static PyObject*
239 : 0 : test_hashtable(PyObject *self, PyObject *Py_UNUSED(args))
240 : : {
241 : 0 : _Py_hashtable_t *table = _Py_hashtable_new(hash_char,
242 : : _Py_hashtable_compare_direct);
243 [ # # ]: 0 : if (table == NULL) {
244 : 0 : return PyErr_NoMemory();
245 : : }
246 : :
247 : : // Using an newly allocated table must not crash
248 [ # # ]: 0 : assert(table->nentries == 0);
249 [ # # ]: 0 : assert(table->nbuckets > 0);
250 [ # # ]: 0 : assert(_Py_hashtable_get(table, TO_PTR('x')) == NULL);
251 : :
252 : : // Test _Py_hashtable_set()
253 : : char key;
254 [ # # ]: 0 : for (key='a'; key <= 'z'; key++) {
255 : 0 : int value = VALUE(key);
256 [ # # ]: 0 : if (_Py_hashtable_set(table, TO_PTR(key), TO_PTR(value)) < 0) {
257 : 0 : _Py_hashtable_destroy(table);
258 : 0 : return PyErr_NoMemory();
259 : : }
260 : : }
261 [ # # ]: 0 : assert(table->nentries == 26);
262 [ # # ]: 0 : assert(table->nbuckets > table->nentries);
263 : :
264 : : // Test _Py_hashtable_get_entry()
265 [ # # ]: 0 : for (key='a'; key <= 'z'; key++) {
266 : 0 : _Py_hashtable_entry_t *entry = _Py_hashtable_get_entry(table, TO_PTR(key));
267 [ # # ]: 0 : assert(entry != NULL);
268 [ # # ]: 0 : assert(entry->key == TO_PTR(key));
269 [ # # ]: 0 : assert(entry->value == TO_PTR(VALUE(key)));
270 : : }
271 : :
272 : : // Test _Py_hashtable_get()
273 [ # # ]: 0 : for (key='a'; key <= 'z'; key++) {
274 : 0 : void *value_ptr = _Py_hashtable_get(table, TO_PTR(key));
275 [ # # ]: 0 : assert((int)FROM_PTR(value_ptr) == VALUE(key));
276 : : }
277 : :
278 : : // Test _Py_hashtable_steal()
279 : 0 : key = 'p';
280 : 0 : void *value_ptr = _Py_hashtable_steal(table, TO_PTR(key));
281 [ # # ]: 0 : assert((int)FROM_PTR(value_ptr) == VALUE(key));
282 [ # # ]: 0 : assert(table->nentries == 25);
283 [ # # ]: 0 : assert(_Py_hashtable_get_entry(table, TO_PTR(key)) == NULL);
284 : :
285 : : // Test _Py_hashtable_foreach()
286 : 0 : int count = 0;
287 : 0 : int res = _Py_hashtable_foreach(table, hashtable_cb, &count);
288 [ # # ]: 0 : assert(res == 0);
289 [ # # ]: 0 : assert(count == 25);
290 : :
291 : : // Test _Py_hashtable_clear()
292 : 0 : _Py_hashtable_clear(table);
293 [ # # ]: 0 : assert(table->nentries == 0);
294 [ # # ]: 0 : assert(table->nbuckets > 0);
295 [ # # ]: 0 : assert(_Py_hashtable_get(table, TO_PTR('x')) == NULL);
296 : :
297 : 0 : _Py_hashtable_destroy(table);
298 : 0 : Py_RETURN_NONE;
299 : : }
300 : :
301 : :
302 : : static PyObject *
303 : 0 : test_get_config(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(args))
304 : : {
305 : : PyConfig config;
306 : 0 : PyConfig_InitIsolatedConfig(&config);
307 [ # # ]: 0 : if (_PyInterpreterState_GetConfigCopy(&config) < 0) {
308 : 0 : PyConfig_Clear(&config);
309 : 0 : return NULL;
310 : : }
311 : 0 : PyObject *dict = _PyConfig_AsDict(&config);
312 : 0 : PyConfig_Clear(&config);
313 : 0 : return dict;
314 : : }
315 : :
316 : :
317 : : static PyObject *
318 : 0 : test_set_config(PyObject *Py_UNUSED(self), PyObject *dict)
319 : : {
320 : : PyConfig config;
321 : 0 : PyConfig_InitIsolatedConfig(&config);
322 [ # # ]: 0 : if (_PyConfig_FromDict(&config, dict) < 0) {
323 : 0 : goto error;
324 : : }
325 [ # # ]: 0 : if (_PyInterpreterState_SetConfig(&config) < 0) {
326 : 0 : goto error;
327 : : }
328 : 0 : PyConfig_Clear(&config);
329 : 0 : Py_RETURN_NONE;
330 : :
331 : 0 : error:
332 : 0 : PyConfig_Clear(&config);
333 : 0 : return NULL;
334 : : }
335 : :
336 : :
337 : : static PyObject *
338 : 0 : test_reset_path_config(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(arg))
339 : : {
340 : 0 : _PyPathConfig_ClearGlobal();
341 : 0 : Py_RETURN_NONE;
342 : : }
343 : :
344 : :
345 : : static PyObject*
346 : 0 : test_atomic_funcs(PyObject *self, PyObject *Py_UNUSED(args))
347 : : {
348 : : // Test _Py_atomic_size_get() and _Py_atomic_size_set()
349 : 0 : Py_ssize_t var = 1;
350 : 0 : _Py_atomic_size_set(&var, 2);
351 [ # # ]: 0 : assert(_Py_atomic_size_get(&var) == 2);
352 : 0 : Py_RETURN_NONE;
353 : : }
354 : :
355 : :
356 : : static int
357 : 0 : check_edit_cost(const char *a, const char *b, Py_ssize_t expected)
358 : : {
359 : 0 : int ret = -1;
360 : 0 : PyObject *a_obj = NULL;
361 : 0 : PyObject *b_obj = NULL;
362 : :
363 : 0 : a_obj = PyUnicode_FromString(a);
364 [ # # ]: 0 : if (a_obj == NULL) {
365 : 0 : goto exit;
366 : : }
367 : 0 : b_obj = PyUnicode_FromString(b);
368 [ # # ]: 0 : if (b_obj == NULL) {
369 : 0 : goto exit;
370 : : }
371 : 0 : Py_ssize_t result = _Py_UTF8_Edit_Cost(a_obj, b_obj, -1);
372 [ # # ]: 0 : if (result != expected) {
373 : 0 : PyErr_Format(PyExc_AssertionError,
374 : : "Edit cost from '%s' to '%s' returns %zd, expected %zd",
375 : : a, b, result, expected);
376 : 0 : goto exit;
377 : : }
378 : : // Check that smaller max_edits thresholds are exceeded.
379 : 0 : Py_ssize_t max_edits = result;
380 [ # # ]: 0 : while (max_edits > 0) {
381 : 0 : max_edits /= 2;
382 : 0 : Py_ssize_t result2 = _Py_UTF8_Edit_Cost(a_obj, b_obj, max_edits);
383 [ # # ]: 0 : if (result2 <= max_edits) {
384 : 0 : PyErr_Format(PyExc_AssertionError,
385 : : "Edit cost from '%s' to '%s' (threshold %zd) "
386 : : "returns %zd, expected greater than %zd",
387 : : a, b, max_edits, result2, max_edits);
388 : 0 : goto exit;
389 : : }
390 : : }
391 : : // Check that bigger max_edits thresholds don't change anything
392 : 0 : Py_ssize_t result3 = _Py_UTF8_Edit_Cost(a_obj, b_obj, result * 2 + 1);
393 [ # # ]: 0 : if (result3 != result) {
394 : 0 : PyErr_Format(PyExc_AssertionError,
395 : : "Edit cost from '%s' to '%s' (threshold %zd) "
396 : : "returns %zd, expected %zd",
397 : : a, b, result * 2, result3, result);
398 : 0 : goto exit;
399 : : }
400 : 0 : ret = 0;
401 : 0 : exit:
402 : 0 : Py_XDECREF(a_obj);
403 : 0 : Py_XDECREF(b_obj);
404 : 0 : return ret;
405 : : }
406 : :
407 : : static PyObject *
408 : 0 : test_edit_cost(PyObject *self, PyObject *Py_UNUSED(args))
409 : : {
410 : : #define CHECK(a, b, n) do { \
411 : : if (check_edit_cost(a, b, n) < 0) { \
412 : : return NULL; \
413 : : } \
414 : : } while (0) \
415 : :
416 [ # # ]: 0 : CHECK("", "", 0);
417 [ # # ]: 0 : CHECK("", "a", 2);
418 [ # # ]: 0 : CHECK("a", "A", 1);
419 [ # # ]: 0 : CHECK("Apple", "Aple", 2);
420 [ # # ]: 0 : CHECK("Banana", "B@n@n@", 6);
421 [ # # ]: 0 : CHECK("Cherry", "Cherry!", 2);
422 [ # # ]: 0 : CHECK("---0---", "------", 2);
423 [ # # ]: 0 : CHECK("abc", "y", 6);
424 [ # # ]: 0 : CHECK("aa", "bb", 4);
425 [ # # ]: 0 : CHECK("aaaaa", "AAAAA", 5);
426 [ # # ]: 0 : CHECK("wxyz", "wXyZ", 2);
427 [ # # ]: 0 : CHECK("wxyz", "wXyZ123", 8);
428 [ # # ]: 0 : CHECK("Python", "Java", 12);
429 [ # # ]: 0 : CHECK("Java", "C#", 8);
430 [ # # ]: 0 : CHECK("AbstractFoobarManager", "abstract_foobar_manager", 3+2*2);
431 [ # # ]: 0 : CHECK("CPython", "PyPy", 10);
432 [ # # ]: 0 : CHECK("CPython", "pypy", 11);
433 [ # # ]: 0 : CHECK("AttributeError", "AttributeErrop", 2);
434 [ # # ]: 0 : CHECK("AttributeError", "AttributeErrorTests", 10);
435 : :
436 : : #undef CHECK
437 : 0 : Py_RETURN_NONE;
438 : : }
439 : :
440 : :
441 : : static PyObject *
442 : 0 : normalize_path(PyObject *self, PyObject *filename)
443 : : {
444 : 0 : Py_ssize_t size = -1;
445 : 0 : wchar_t *encoded = PyUnicode_AsWideCharString(filename, &size);
446 [ # # ]: 0 : if (encoded == NULL) {
447 : 0 : return NULL;
448 : : }
449 : :
450 : 0 : PyObject *result = PyUnicode_FromWideChar(_Py_normpath(encoded, size), -1);
451 : 0 : PyMem_Free(encoded);
452 : :
453 : 0 : return result;
454 : : }
455 : :
456 : : static PyObject *
457 : 0 : get_getpath_codeobject(PyObject *self, PyObject *Py_UNUSED(args)) {
458 : 0 : return _Py_Get_Getpath_CodeObject();
459 : : }
460 : :
461 : :
462 : : static PyObject *
463 : 0 : encode_locale_ex(PyObject *self, PyObject *args)
464 : : {
465 : : PyObject *unicode;
466 : 0 : int current_locale = 0;
467 : : wchar_t *wstr;
468 : 0 : PyObject *res = NULL;
469 : 0 : const char *errors = NULL;
470 : :
471 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "U|is", &unicode, ¤t_locale, &errors)) {
472 : 0 : return NULL;
473 : : }
474 : 0 : wstr = PyUnicode_AsWideCharString(unicode, NULL);
475 [ # # ]: 0 : if (wstr == NULL) {
476 : 0 : return NULL;
477 : : }
478 : 0 : _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
479 : :
480 : 0 : char *str = NULL;
481 : : size_t error_pos;
482 : 0 : const char *reason = NULL;
483 : 0 : int ret = _Py_EncodeLocaleEx(wstr,
484 : : &str, &error_pos, &reason,
485 : : current_locale, error_handler);
486 : 0 : PyMem_Free(wstr);
487 : :
488 [ # # # # : 0 : switch(ret) {
# ]
489 : 0 : case 0:
490 : 0 : res = PyBytes_FromString(str);
491 : 0 : PyMem_RawFree(str);
492 : 0 : break;
493 : 0 : case -1:
494 : 0 : PyErr_NoMemory();
495 : 0 : break;
496 : 0 : case -2:
497 : 0 : PyErr_Format(PyExc_RuntimeError, "encode error: pos=%zu, reason=%s",
498 : : error_pos, reason);
499 : 0 : break;
500 : 0 : case -3:
501 : 0 : PyErr_SetString(PyExc_ValueError, "unsupported error handler");
502 : 0 : break;
503 : 0 : default:
504 : 0 : PyErr_SetString(PyExc_ValueError, "unknown error code");
505 : 0 : break;
506 : : }
507 : 0 : return res;
508 : : }
509 : :
510 : :
511 : : static PyObject *
512 : 0 : decode_locale_ex(PyObject *self, PyObject *args)
513 : : {
514 : : char *str;
515 : 0 : int current_locale = 0;
516 : 0 : PyObject *res = NULL;
517 : 0 : const char *errors = NULL;
518 : :
519 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "y|is", &str, ¤t_locale, &errors)) {
520 : 0 : return NULL;
521 : : }
522 : 0 : _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
523 : :
524 : 0 : wchar_t *wstr = NULL;
525 : 0 : size_t wlen = 0;
526 : 0 : const char *reason = NULL;
527 : 0 : int ret = _Py_DecodeLocaleEx(str,
528 : : &wstr, &wlen, &reason,
529 : : current_locale, error_handler);
530 : :
531 [ # # # # : 0 : switch(ret) {
# ]
532 : 0 : case 0:
533 : 0 : res = PyUnicode_FromWideChar(wstr, wlen);
534 : 0 : PyMem_RawFree(wstr);
535 : 0 : break;
536 : 0 : case -1:
537 : 0 : PyErr_NoMemory();
538 : 0 : break;
539 : 0 : case -2:
540 : 0 : PyErr_Format(PyExc_RuntimeError, "decode error: pos=%zu, reason=%s",
541 : : wlen, reason);
542 : 0 : break;
543 : 0 : case -3:
544 : 0 : PyErr_SetString(PyExc_ValueError, "unsupported error handler");
545 : 0 : break;
546 : 0 : default:
547 : 0 : PyErr_SetString(PyExc_ValueError, "unknown error code");
548 : 0 : break;
549 : : }
550 : 0 : return res;
551 : : }
552 : :
553 : : static PyObject *
554 : 0 : set_eval_frame_default(PyObject *self, PyObject *Py_UNUSED(args))
555 : : {
556 : 0 : module_state *state = get_module_state(self);
557 : 0 : _PyInterpreterState_SetEvalFrameFunc(PyInterpreterState_Get(), _PyEval_EvalFrameDefault);
558 [ # # ]: 0 : Py_CLEAR(state->record_list);
559 : 0 : Py_RETURN_NONE;
560 : : }
561 : :
562 : : static PyObject *
563 : 0 : record_eval(PyThreadState *tstate, struct _PyInterpreterFrame *f, int exc)
564 : : {
565 [ # # ]: 0 : if (PyFunction_Check(f->f_funcobj)) {
566 : 0 : PyObject *module = _get_current_module();
567 [ # # ]: 0 : assert(module != NULL);
568 : 0 : module_state *state = get_module_state(module);
569 : 0 : Py_DECREF(module);
570 : 0 : PyList_Append(state->record_list, ((PyFunctionObject *)f->f_funcobj)->func_name);
571 : : }
572 : 0 : return _PyEval_EvalFrameDefault(tstate, f, exc);
573 : : }
574 : :
575 : :
576 : : static PyObject *
577 : 0 : set_eval_frame_record(PyObject *self, PyObject *list)
578 : : {
579 : 0 : module_state *state = get_module_state(self);
580 [ # # ]: 0 : if (!PyList_Check(list)) {
581 : 0 : PyErr_SetString(PyExc_TypeError, "argument must be a list");
582 : 0 : return NULL;
583 : : }
584 : 0 : Py_XSETREF(state->record_list, Py_NewRef(list));
585 : 0 : _PyInterpreterState_SetEvalFrameFunc(PyInterpreterState_Get(), record_eval);
586 : 0 : Py_RETURN_NONE;
587 : : }
588 : :
589 : : /*[clinic input]
590 : :
591 : : _testinternalcapi.compiler_codegen -> object
592 : :
593 : : ast: object
594 : : filename: object
595 : : optimize: int
596 : :
597 : : Apply compiler code generation to an AST.
598 : : [clinic start generated code]*/
599 : :
600 : : static PyObject *
601 : 0 : _testinternalcapi_compiler_codegen_impl(PyObject *module, PyObject *ast,
602 : : PyObject *filename, int optimize)
603 : : /*[clinic end generated code: output=fbbbbfb34700c804 input=e9fbe6562f7f75e4]*/
604 : : {
605 : 0 : PyCompilerFlags *flags = NULL;
606 : 0 : return _PyCompile_CodeGen(ast, filename, flags, optimize);
607 : : }
608 : :
609 : :
610 : : /*[clinic input]
611 : :
612 : : _testinternalcapi.optimize_cfg -> object
613 : :
614 : : instructions: object
615 : : consts: object
616 : :
617 : : Apply compiler optimizations to an instruction list.
618 : : [clinic start generated code]*/
619 : :
620 : : static PyObject *
621 : 0 : _testinternalcapi_optimize_cfg_impl(PyObject *module, PyObject *instructions,
622 : : PyObject *consts)
623 : : /*[clinic end generated code: output=5412aeafca683c8b input=7e8a3de86ebdd0f9]*/
624 : : {
625 : 0 : return _PyCompile_OptimizeCfg(instructions, consts);
626 : : }
627 : :
628 : :
629 : : static PyObject *
630 : 0 : get_interp_settings(PyObject *self, PyObject *args)
631 : : {
632 : 0 : int interpid = -1;
633 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "|i:get_interp_settings", &interpid)) {
634 : 0 : return NULL;
635 : : }
636 : :
637 : 0 : PyInterpreterState *interp = NULL;
638 [ # # ]: 0 : if (interpid < 0) {
639 : 0 : PyThreadState *tstate = _PyThreadState_GET();
640 [ # # ]: 0 : interp = tstate ? tstate->interp : _PyInterpreterState_Main();
641 : : }
642 [ # # ]: 0 : else if (interpid == 0) {
643 : 0 : interp = _PyInterpreterState_Main();
644 : : }
645 : : else {
646 : 0 : PyErr_Format(PyExc_NotImplementedError,
647 : : "%zd", interpid);
648 : 0 : return NULL;
649 : : }
650 [ # # ]: 0 : assert(interp != NULL);
651 : :
652 : 0 : PyObject *settings = PyDict_New();
653 [ # # ]: 0 : if (settings == NULL) {
654 : 0 : return NULL;
655 : : }
656 : :
657 : : /* Add the feature flags. */
658 : 0 : PyObject *flags = PyLong_FromUnsignedLong(interp->feature_flags);
659 [ # # ]: 0 : if (flags == NULL) {
660 : 0 : Py_DECREF(settings);
661 : 0 : return NULL;
662 : : }
663 : 0 : int res = PyDict_SetItemString(settings, "feature_flags", flags);
664 : 0 : Py_DECREF(flags);
665 [ # # ]: 0 : if (res != 0) {
666 : 0 : Py_DECREF(settings);
667 : 0 : return NULL;
668 : : }
669 : :
670 : 0 : return settings;
671 : : }
672 : :
673 : :
674 : : static PyObject *
675 : 0 : clear_extension(PyObject *self, PyObject *args)
676 : : {
677 : 0 : PyObject *name = NULL, *filename = NULL;
678 [ # # ]: 0 : if (!PyArg_ParseTuple(args, "OO:clear_extension", &name, &filename)) {
679 : 0 : return NULL;
680 : : }
681 [ # # ]: 0 : if (_PyImport_ClearExtension(name, filename) < 0) {
682 : 0 : return NULL;
683 : : }
684 : 0 : Py_RETURN_NONE;
685 : : }
686 : :
687 : :
688 : : static PyMethodDef module_functions[] = {
689 : : {"get_configs", get_configs, METH_NOARGS},
690 : : {"get_recursion_depth", get_recursion_depth, METH_NOARGS},
691 : : {"test_bswap", test_bswap, METH_NOARGS},
692 : : {"test_popcount", test_popcount, METH_NOARGS},
693 : : {"test_bit_length", test_bit_length, METH_NOARGS},
694 : : {"test_hashtable", test_hashtable, METH_NOARGS},
695 : : {"get_config", test_get_config, METH_NOARGS},
696 : : {"set_config", test_set_config, METH_O},
697 : : {"reset_path_config", test_reset_path_config, METH_NOARGS},
698 : : {"test_atomic_funcs", test_atomic_funcs, METH_NOARGS},
699 : : {"test_edit_cost", test_edit_cost, METH_NOARGS},
700 : : {"normalize_path", normalize_path, METH_O, NULL},
701 : : {"get_getpath_codeobject", get_getpath_codeobject, METH_NOARGS, NULL},
702 : : {"EncodeLocaleEx", encode_locale_ex, METH_VARARGS},
703 : : {"DecodeLocaleEx", decode_locale_ex, METH_VARARGS},
704 : : {"set_eval_frame_default", set_eval_frame_default, METH_NOARGS, NULL},
705 : : {"set_eval_frame_record", set_eval_frame_record, METH_O, NULL},
706 : : _TESTINTERNALCAPI_COMPILER_CODEGEN_METHODDEF
707 : : _TESTINTERNALCAPI_OPTIMIZE_CFG_METHODDEF
708 : : {"get_interp_settings", get_interp_settings, METH_VARARGS, NULL},
709 : : {"clear_extension", clear_extension, METH_VARARGS, NULL},
710 : : {NULL, NULL} /* sentinel */
711 : : };
712 : :
713 : :
714 : : /* initialization function */
715 : :
716 : : static int
717 : 1 : module_exec(PyObject *module)
718 : : {
719 [ - + ]: 1 : if (PyModule_AddObject(module, "SIZEOF_PYGC_HEAD",
720 : : PyLong_FromSsize_t(sizeof(PyGC_Head))) < 0) {
721 : 0 : return 1;
722 : : }
723 : :
724 : 1 : return 0;
725 : : }
726 : :
727 : : static struct PyModuleDef_Slot module_slots[] = {
728 : : {Py_mod_exec, module_exec},
729 : : {0, NULL},
730 : : };
731 : :
732 : : static int
733 : 6 : module_traverse(PyObject *module, visitproc visit, void *arg)
734 : : {
735 : 6 : module_state *state = get_module_state(module);
736 [ - + ]: 6 : assert(state != NULL);
737 : 6 : traverse_module_state(state, visit, arg);
738 : 6 : return 0;
739 : : }
740 : :
741 : : static int
742 : 1 : module_clear(PyObject *module)
743 : : {
744 : 1 : module_state *state = get_module_state(module);
745 [ - + ]: 1 : assert(state != NULL);
746 : 1 : (void)clear_module_state(state);
747 : 1 : return 0;
748 : : }
749 : :
750 : : static void
751 : 1 : module_free(void *module)
752 : : {
753 : 1 : module_state *state = get_module_state(module);
754 [ - + ]: 1 : assert(state != NULL);
755 : 1 : (void)clear_module_state(state);
756 : 1 : }
757 : :
758 : : static struct PyModuleDef _testcapimodule = {
759 : : .m_base = PyModuleDef_HEAD_INIT,
760 : : .m_name = MODULE_NAME,
761 : : .m_doc = NULL,
762 : : .m_size = sizeof(module_state),
763 : : .m_methods = module_functions,
764 : : .m_slots = module_slots,
765 : : .m_traverse = module_traverse,
766 : : .m_clear = module_clear,
767 : : .m_free = (freefunc)module_free,
768 : : };
769 : :
770 : :
771 : : PyMODINIT_FUNC
772 : 1 : PyInit__testinternalcapi(void)
773 : : {
774 : 1 : return PyModuleDef_Init(&_testcapimodule);
775 : : }
|