Branch data Line data Source code
1 : :
2 : : /* Module support implementation */
3 : :
4 : : #include "Python.h"
5 : : #include "pycore_abstract.h" // _PyIndex_Check()
6 : :
7 : : #define FLAG_SIZE_T 1
8 : : typedef double va_double;
9 : :
10 : : static PyObject *va_build_value(const char *, va_list, int);
11 : : static PyObject **va_build_stack(PyObject **small_stack, Py_ssize_t small_stack_len, const char *, va_list, int, Py_ssize_t*);
12 : :
13 : : /* Package context -- the full module name for package imports */
14 : : const char *_Py_PackageContext = NULL;
15 : :
16 : :
17 : : int
18 : 11997465 : _Py_convert_optional_to_ssize_t(PyObject *obj, void *result)
19 : : {
20 : : Py_ssize_t limit;
21 [ + + ]: 11997465 : if (obj == Py_None) {
22 : 107 : return 1;
23 : : }
24 [ + + ]: 11997358 : else if (_PyIndex_Check(obj)) {
25 : 11997335 : limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError);
26 [ + + + + ]: 11997335 : if (limit == -1 && PyErr_Occurred()) {
27 : 5 : return 0;
28 : : }
29 : : }
30 : : else {
31 : 23 : PyErr_Format(PyExc_TypeError,
32 : : "argument should be integer or None, not '%.200s'",
33 : 23 : Py_TYPE(obj)->tp_name);
34 : 23 : return 0;
35 : : }
36 : 11997330 : *((Py_ssize_t *)result) = limit;
37 : 11997330 : return 1;
38 : : }
39 : :
40 : :
41 : : /* Helper for mkvalue() to scan the length of a format */
42 : :
43 : : static Py_ssize_t
44 : 11920013 : countformat(const char *format, char endchar)
45 : : {
46 : 11920013 : Py_ssize_t count = 0;
47 : 11920013 : int level = 0;
48 [ + + + + ]: 51668191 : while (level > 0 || *format != endchar) {
49 [ - + + + : 39748178 : switch (*format) {
+ ]
50 : 0 : case '\0':
51 : : /* Premature end */
52 : 0 : PyErr_SetString(PyExc_SystemError,
53 : : "unmatched paren in format");
54 : 0 : return -1;
55 : 2173122 : case '(':
56 : : case '[':
57 : : case '{':
58 [ + + ]: 2173122 : if (level == 0) {
59 : 2152083 : count++;
60 : : }
61 : 2173122 : level++;
62 : 2173122 : break;
63 : 2173122 : case ')':
64 : : case ']':
65 : : case '}':
66 : 2173122 : level--;
67 : 2173122 : break;
68 : 5289106 : case '#':
69 : : case '&':
70 : : case ',':
71 : : case ':':
72 : : case ' ':
73 : : case '\t':
74 : 5289106 : break;
75 : 30112828 : default:
76 [ + + ]: 30112828 : if (level == 0) {
77 : 23242420 : count++;
78 : : }
79 : : }
80 : 39748178 : format++;
81 : : }
82 : 11920013 : return count;
83 : : }
84 : :
85 : :
86 : : /* Generic function to create a value -- the inverse of getargs() */
87 : : /* After an original idea and first implementation by Steven Miale */
88 : :
89 : : static PyObject *do_mktuple(const char**, va_list *, char, Py_ssize_t, int);
90 : : static int do_mkstack(PyObject **, const char**, va_list *, char, Py_ssize_t, int);
91 : : static PyObject *do_mklist(const char**, va_list *, char, Py_ssize_t, int);
92 : : static PyObject *do_mkdict(const char**, va_list *, char, Py_ssize_t, int);
93 : : static PyObject *do_mkvalue(const char**, va_list *, int);
94 : :
95 : :
96 : : static void
97 : 24 : do_ignore(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
98 : : {
99 : : PyObject *v;
100 : : Py_ssize_t i;
101 : : assert(PyErr_Occurred());
102 : 24 : v = PyTuple_New(n);
103 [ + + ]: 50 : for (i = 0; i < n; i++) {
104 : : PyObject *exception, *value, *tb, *w;
105 : :
106 : 26 : PyErr_Fetch(&exception, &value, &tb);
107 : 26 : w = do_mkvalue(p_format, p_va, flags);
108 : 26 : PyErr_Restore(exception, value, tb);
109 [ + - ]: 26 : if (w != NULL) {
110 [ + - ]: 26 : if (v != NULL) {
111 : 26 : PyTuple_SET_ITEM(v, i, w);
112 : : }
113 : : else {
114 : 0 : Py_DECREF(w);
115 : : }
116 : : }
117 : : }
118 : 24 : Py_XDECREF(v);
119 [ - + ]: 24 : if (**p_format != endchar) {
120 : 0 : PyErr_SetString(PyExc_SystemError,
121 : : "Unmatched paren in format");
122 : 0 : return;
123 : : }
124 [ + + ]: 24 : if (endchar) {
125 : 12 : ++*p_format;
126 : : }
127 : : }
128 : :
129 : : static PyObject *
130 : 207508 : do_mkdict(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
131 : : {
132 : : PyObject *d;
133 : : Py_ssize_t i;
134 [ - + ]: 207508 : if (n < 0)
135 : 0 : return NULL;
136 [ - + ]: 207508 : if (n % 2) {
137 : 0 : PyErr_SetString(PyExc_SystemError,
138 : : "Bad dict format");
139 : 0 : do_ignore(p_format, p_va, endchar, n, flags);
140 : 0 : return NULL;
141 : : }
142 : : /* Note that we can't bail immediately on error as this will leak
143 : : refcounts on any 'N' arguments. */
144 [ - + ]: 207508 : if ((d = PyDict_New()) == NULL) {
145 : 0 : do_ignore(p_format, p_va, endchar, n, flags);
146 : 0 : return NULL;
147 : : }
148 [ + + ]: 929179 : for (i = 0; i < n; i+= 2) {
149 : : PyObject *k, *v;
150 : :
151 : 721675 : k = do_mkvalue(p_format, p_va, flags);
152 [ + + ]: 721675 : if (k == NULL) {
153 : 2 : do_ignore(p_format, p_va, endchar, n - i - 1, flags);
154 : 2 : Py_DECREF(d);
155 : 2 : return NULL;
156 : : }
157 : 721673 : v = do_mkvalue(p_format, p_va, flags);
158 [ + + - + ]: 721673 : if (v == NULL || PyDict_SetItem(d, k, v) < 0) {
159 : 2 : do_ignore(p_format, p_va, endchar, n - i - 2, flags);
160 : 2 : Py_DECREF(k);
161 : 2 : Py_XDECREF(v);
162 : 2 : Py_DECREF(d);
163 : 2 : return NULL;
164 : : }
165 : 721671 : Py_DECREF(k);
166 : 721671 : Py_DECREF(v);
167 : : }
168 [ - + ]: 207504 : if (**p_format != endchar) {
169 : 0 : Py_DECREF(d);
170 : 0 : PyErr_SetString(PyExc_SystemError,
171 : : "Unmatched paren in format");
172 : 0 : return NULL;
173 : : }
174 [ + - ]: 207504 : if (endchar)
175 : 207504 : ++*p_format;
176 : 207504 : return d;
177 : : }
178 : :
179 : : static PyObject *
180 : 5 : do_mklist(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
181 : : {
182 : : PyObject *v;
183 : : Py_ssize_t i;
184 [ - + ]: 5 : if (n < 0)
185 : 0 : return NULL;
186 : : /* Note that we can't bail immediately on error as this will leak
187 : : refcounts on any 'N' arguments. */
188 : 5 : v = PyList_New(n);
189 [ - + ]: 5 : if (v == NULL) {
190 : 0 : do_ignore(p_format, p_va, endchar, n, flags);
191 : 0 : return NULL;
192 : : }
193 [ + + ]: 13 : for (i = 0; i < n; i++) {
194 : 10 : PyObject *w = do_mkvalue(p_format, p_va, flags);
195 [ + + ]: 10 : if (w == NULL) {
196 : 2 : do_ignore(p_format, p_va, endchar, n - i - 1, flags);
197 : 2 : Py_DECREF(v);
198 : 2 : return NULL;
199 : : }
200 : 8 : PyList_SET_ITEM(v, i, w);
201 : : }
202 [ - + ]: 3 : if (**p_format != endchar) {
203 : 0 : Py_DECREF(v);
204 : 0 : PyErr_SetString(PyExc_SystemError,
205 : : "Unmatched paren in format");
206 : 0 : return NULL;
207 : : }
208 [ + - ]: 3 : if (endchar)
209 : 3 : ++*p_format;
210 : 3 : return v;
211 : : }
212 : :
213 : : static int
214 : 2111697 : do_mkstack(PyObject **stack, const char **p_format, va_list *p_va,
215 : : char endchar, Py_ssize_t n, int flags)
216 : : {
217 : : Py_ssize_t i;
218 : :
219 [ - + ]: 2111697 : if (n < 0) {
220 : 0 : return -1;
221 : : }
222 : : /* Note that we can't bail immediately on error as this will leak
223 : : refcounts on any 'N' arguments. */
224 [ + + ]: 8598970 : for (i = 0; i < n; i++) {
225 : 6487273 : PyObject *w = do_mkvalue(p_format, p_va, flags);
226 [ - + ]: 6487273 : if (w == NULL) {
227 : 0 : do_ignore(p_format, p_va, endchar, n - i - 1, flags);
228 : 0 : goto error;
229 : : }
230 : 6487273 : stack[i] = w;
231 : : }
232 [ - + ]: 2111697 : if (**p_format != endchar) {
233 : 0 : PyErr_SetString(PyExc_SystemError,
234 : : "Unmatched paren in format");
235 : 0 : goto error;
236 : : }
237 [ - + ]: 2111697 : if (endchar) {
238 : 0 : ++*p_format;
239 : : }
240 : 2111697 : return 0;
241 : :
242 : 0 : error:
243 : 0 : n = i;
244 [ # # ]: 0 : for (i=0; i < n; i++) {
245 : 0 : Py_DECREF(stack[i]);
246 : : }
247 : 0 : return -1;
248 : : }
249 : :
250 : : static PyObject *
251 : 5543680 : do_mktuple(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
252 : : {
253 : : PyObject *v;
254 : : Py_ssize_t i;
255 [ - + ]: 5543680 : if (n < 0)
256 : 0 : return NULL;
257 : : /* Note that we can't bail immediately on error as this will leak
258 : : refcounts on any 'N' arguments. */
259 [ - + ]: 5543680 : if ((v = PyTuple_New(n)) == NULL) {
260 : 0 : do_ignore(p_format, p_va, endchar, n, flags);
261 : 0 : return NULL;
262 : : }
263 [ + + ]: 18950385 : for (i = 0; i < n; i++) {
264 : 13406723 : PyObject *w = do_mkvalue(p_format, p_va, flags);
265 [ + + ]: 13406723 : if (w == NULL) {
266 : 18 : do_ignore(p_format, p_va, endchar, n - i - 1, flags);
267 : 18 : Py_DECREF(v);
268 : 18 : return NULL;
269 : : }
270 : 13406705 : PyTuple_SET_ITEM(v, i, w);
271 : : }
272 [ - + ]: 5543662 : if (**p_format != endchar) {
273 : 0 : Py_DECREF(v);
274 : 0 : PyErr_SetString(PyExc_SystemError,
275 : : "Unmatched paren in format");
276 : 0 : return NULL;
277 : : }
278 [ + + ]: 5543662 : if (endchar)
279 : 1944564 : ++*p_format;
280 : 5543662 : return v;
281 : : }
282 : :
283 : : static PyObject *
284 : 25394503 : do_mkvalue(const char **p_format, va_list *p_va, int flags)
285 : : {
286 : : #define ERROR_NEED_PY_SSIZE_T_CLEAN \
287 : : { \
288 : : PyErr_SetString(PyExc_SystemError, \
289 : : "PY_SSIZE_T_CLEAN macro must be defined for '#' formats"); \
290 : : return NULL; \
291 : : }
292 : :
293 : : for (;;) {
294 [ + + + + : 25394884 : switch (*(*p_format)++) {
- + + + +
+ + + - +
+ + + + +
- ]
295 : 1944570 : case '(':
296 : 1944570 : return do_mktuple(p_format, p_va, ')',
297 : : countformat(*p_format, ')'), flags);
298 : :
299 : 5 : case '[':
300 : 5 : return do_mklist(p_format, p_va, ']',
301 : : countformat(*p_format, ']'), flags);
302 : :
303 : 207508 : case '{':
304 : 207508 : return do_mkdict(p_format, p_va, '}',
305 : : countformat(*p_format, '}'), flags);
306 : :
307 : 4635759 : case 'b':
308 : : case 'B':
309 : : case 'h':
310 : : case 'i':
311 : 4635759 : return PyLong_FromLong((long)va_arg(*p_va, int));
312 : :
313 : 0 : case 'H':
314 : 0 : return PyLong_FromLong((long)va_arg(*p_va, unsigned int));
315 : :
316 : 45445 : case 'I':
317 : : {
318 : : unsigned int n;
319 : 45445 : n = va_arg(*p_va, unsigned int);
320 : 45445 : return PyLong_FromUnsignedLong(n);
321 : : }
322 : :
323 : 765993 : case 'n':
324 : : #if SIZEOF_SIZE_T!=SIZEOF_LONG
325 : : return PyLong_FromSsize_t(va_arg(*p_va, Py_ssize_t));
326 : : #endif
327 : : /* Fall through from 'n' to 'l' if Py_ssize_t is long */
328 : : case 'l':
329 : 765993 : return PyLong_FromLong(va_arg(*p_va, long));
330 : :
331 : 863 : case 'k':
332 : : {
333 : : unsigned long n;
334 : 863 : n = va_arg(*p_va, unsigned long);
335 : 863 : return PyLong_FromUnsignedLong(n);
336 : : }
337 : :
338 : 2 : case 'L':
339 : 2 : return PyLong_FromLongLong((long long)va_arg(*p_va, long long));
340 : :
341 : 38269 : case 'K':
342 : 38269 : return PyLong_FromUnsignedLongLong((long long)va_arg(*p_va, unsigned long long));
343 : :
344 : 101 : case 'u':
345 : : {
346 : : PyObject *v;
347 : 101 : Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
348 : : Py_ssize_t n;
349 [ + + ]: 101 : if (**p_format == '#') {
350 : 1 : ++*p_format;
351 [ - + ]: 1 : if (flags & FLAG_SIZE_T) {
352 : 0 : n = va_arg(*p_va, Py_ssize_t);
353 : : }
354 : : else {
355 : 1 : n = va_arg(*p_va, int);
356 : 1 : ERROR_NEED_PY_SSIZE_T_CLEAN;
357 : : }
358 : : }
359 : : else
360 : 100 : n = -1;
361 [ - + ]: 100 : if (u == NULL) {
362 : 0 : v = Py_None;
363 : 0 : Py_INCREF(v);
364 : : }
365 : : else {
366 [ + - ]: 100 : if (n < 0)
367 : 100 : n = wcslen(u);
368 : 100 : v = PyUnicode_FromWideChar(u, n);
369 : : }
370 : 100 : return v;
371 : : }
372 : 534157 : case 'f':
373 : : case 'd':
374 : 534157 : return PyFloat_FromDouble(
375 : 534157 : (double)va_arg(*p_va, va_double));
376 : :
377 : 0 : case 'D':
378 : 0 : return PyComplex_FromCComplex(
379 : 0 : *((Py_complex *)va_arg(*p_va, Py_complex *)));
380 : :
381 : 58398 : case 'c':
382 : : {
383 : : char p[1];
384 : 58398 : p[0] = (char)va_arg(*p_va, int);
385 : 58398 : return PyBytes_FromStringAndSize(p, 1);
386 : : }
387 : 72697 : case 'C':
388 : : {
389 : 72697 : int i = va_arg(*p_va, int);
390 : 72697 : return PyUnicode_FromOrdinal(i);
391 : : }
392 : :
393 : 2416207 : case 's':
394 : : case 'z':
395 : : case 'U': /* XXX deprecated alias */
396 : : {
397 : : PyObject *v;
398 : 2416207 : const char *str = va_arg(*p_va, const char *);
399 : : Py_ssize_t n;
400 [ + + ]: 2416207 : if (**p_format == '#') {
401 : 539 : ++*p_format;
402 [ + + ]: 539 : if (flags & FLAG_SIZE_T) {
403 : 537 : n = va_arg(*p_va, Py_ssize_t);
404 : : }
405 : : else {
406 : 2 : n = va_arg(*p_va, int);
407 : 2 : ERROR_NEED_PY_SSIZE_T_CLEAN;
408 : : }
409 : : }
410 : : else
411 : 2415668 : n = -1;
412 [ + + ]: 2416205 : if (str == NULL) {
413 : 23414 : v = Py_None;
414 : 23414 : Py_INCREF(v);
415 : : }
416 : : else {
417 [ + + ]: 2392791 : if (n < 0) {
418 : 2392254 : size_t m = strlen(str);
419 [ - + ]: 2392254 : if (m > PY_SSIZE_T_MAX) {
420 : 0 : PyErr_SetString(PyExc_OverflowError,
421 : : "string too long for Python string");
422 : 0 : return NULL;
423 : : }
424 : 2392254 : n = (Py_ssize_t)m;
425 : : }
426 : 2392791 : v = PyUnicode_FromStringAndSize(str, n);
427 : : }
428 : 2416205 : return v;
429 : : }
430 : :
431 : 131387 : case 'y':
432 : : {
433 : : PyObject *v;
434 : 131387 : const char *str = va_arg(*p_va, const char *);
435 : : Py_ssize_t n;
436 [ + + ]: 131387 : if (**p_format == '#') {
437 : 58589 : ++*p_format;
438 [ + + ]: 58589 : if (flags & FLAG_SIZE_T) {
439 : 58588 : n = va_arg(*p_va, Py_ssize_t);
440 : : }
441 : : else {
442 : 1 : n = va_arg(*p_va, int);
443 : 1 : ERROR_NEED_PY_SSIZE_T_CLEAN;
444 : : }
445 : : }
446 : : else
447 : 72798 : n = -1;
448 [ - + ]: 131386 : if (str == NULL) {
449 : 0 : v = Py_None;
450 : 0 : Py_INCREF(v);
451 : : }
452 : : else {
453 [ + + ]: 131386 : if (n < 0) {
454 : 72798 : size_t m = strlen(str);
455 [ - + ]: 72798 : if (m > PY_SSIZE_T_MAX) {
456 : 0 : PyErr_SetString(PyExc_OverflowError,
457 : : "string too long for Python bytes");
458 : 0 : return NULL;
459 : : }
460 : 72798 : n = (Py_ssize_t)m;
461 : : }
462 : 131386 : v = PyBytes_FromStringAndSize(str, n);
463 : : }
464 : 131386 : return v;
465 : : }
466 : :
467 : 14543142 : case 'N':
468 : : case 'S':
469 : : case 'O':
470 [ + + ]: 14543142 : if (**p_format == '&') {
471 : : typedef PyObject *(*converter)(void *);
472 : 2614593 : converter func = va_arg(*p_va, converter);
473 : 2614593 : void *arg = va_arg(*p_va, void *);
474 : 2614593 : ++*p_format;
475 : 2614593 : return (*func)(arg);
476 : : }
477 : : else {
478 : : PyObject *v;
479 : 11928549 : v = va_arg(*p_va, PyObject *);
480 [ + + ]: 11928549 : if (v != NULL) {
481 [ + + ]: 11928539 : if (*(*p_format - 1) != 'N')
482 : 10940358 : Py_INCREF(v);
483 : : }
484 [ - + ]: 10 : else if (!PyErr_Occurred())
485 : : /* If a NULL was passed
486 : : * because a call that should
487 : : * have constructed a value
488 : : * failed, that's OK, and we
489 : : * pass the error on; but if
490 : : * no error occurred it's not
491 : : * clear that the caller knew
492 : : * what she was doing. */
493 : 0 : PyErr_SetString(PyExc_SystemError,
494 : : "NULL object passed to Py_BuildValue");
495 : 11928549 : return v;
496 : : }
497 : :
498 : 381 : case ':':
499 : : case ',':
500 : : case ' ':
501 : : case '\t':
502 : 381 : break;
503 : :
504 : 0 : default:
505 : 0 : PyErr_SetString(PyExc_SystemError,
506 : : "bad format char passed to Py_BuildValue");
507 : 0 : return NULL;
508 : :
509 : : }
510 : : }
511 : :
512 : : #undef ERROR_NEED_PY_SSIZE_T_CLEAN
513 : : }
514 : :
515 : :
516 : : PyObject *
517 : 1774050 : Py_BuildValue(const char *format, ...)
518 : : {
519 : : va_list va;
520 : : PyObject* retval;
521 : 1774050 : va_start(va, format);
522 : 1774050 : retval = va_build_value(format, va, 0);
523 : 1774050 : va_end(va);
524 : 1774050 : return retval;
525 : : }
526 : :
527 : : PyObject *
528 : 1537236 : _Py_BuildValue_SizeT(const char *format, ...)
529 : : {
530 : : va_list va;
531 : : PyObject* retval;
532 : 1537236 : va_start(va, format);
533 : 1537236 : retval = va_build_value(format, va, FLAG_SIZE_T);
534 : 1537236 : va_end(va);
535 : 1537236 : return retval;
536 : : }
537 : :
538 : : PyObject *
539 : 0 : Py_VaBuildValue(const char *format, va_list va)
540 : : {
541 : 0 : return va_build_value(format, va, 0);
542 : : }
543 : :
544 : : PyObject *
545 : 4344947 : _Py_VaBuildValue_SizeT(const char *format, va_list va)
546 : : {
547 : 4344947 : return va_build_value(format, va, FLAG_SIZE_T);
548 : : }
549 : :
550 : : static PyObject *
551 : 7656233 : va_build_value(const char *format, va_list va, int flags)
552 : : {
553 : 7656233 : const char *f = format;
554 : 7656233 : Py_ssize_t n = countformat(f, '\0');
555 : : va_list lva;
556 : : PyObject *retval;
557 : :
558 [ - + ]: 7656233 : if (n < 0)
559 : 0 : return NULL;
560 [ - + ]: 7656233 : if (n == 0) {
561 : 0 : Py_RETURN_NONE;
562 : : }
563 : 7656233 : va_copy(lva, va);
564 [ + + ]: 7656233 : if (n == 1) {
565 : 4057123 : retval = do_mkvalue(&f, &lva, flags);
566 : : } else {
567 : 3599110 : retval = do_mktuple(&f, &lva, '\0', n, flags);
568 : : }
569 : 7656233 : va_end(lva);
570 : 7656233 : return retval;
571 : : }
572 : :
573 : : PyObject **
574 : 847941 : _Py_VaBuildStack(PyObject **small_stack, Py_ssize_t small_stack_len,
575 : : const char *format, va_list va, Py_ssize_t *p_nargs)
576 : : {
577 : 847941 : return va_build_stack(small_stack, small_stack_len, format, va, 0, p_nargs);
578 : : }
579 : :
580 : : PyObject **
581 : 1263756 : _Py_VaBuildStack_SizeT(PyObject **small_stack, Py_ssize_t small_stack_len,
582 : : const char *format, va_list va, Py_ssize_t *p_nargs)
583 : : {
584 : 1263756 : return va_build_stack(small_stack, small_stack_len, format, va, FLAG_SIZE_T, p_nargs);
585 : : }
586 : :
587 : : static PyObject **
588 : 2111697 : va_build_stack(PyObject **small_stack, Py_ssize_t small_stack_len,
589 : : const char *format, va_list va, int flags, Py_ssize_t *p_nargs)
590 : : {
591 : : const char *f;
592 : : Py_ssize_t n;
593 : : va_list lva;
594 : : PyObject **stack;
595 : : int res;
596 : :
597 : 2111697 : n = countformat(format, '\0');
598 [ - + ]: 2111697 : if (n < 0) {
599 : 0 : *p_nargs = 0;
600 : 0 : return NULL;
601 : : }
602 : :
603 [ - + ]: 2111697 : if (n == 0) {
604 : 0 : *p_nargs = 0;
605 : 0 : return small_stack;
606 : : }
607 : :
608 [ + + ]: 2111697 : if (n <= small_stack_len) {
609 : 2090391 : stack = small_stack;
610 : : }
611 : : else {
612 : 21306 : stack = PyMem_Malloc(n * sizeof(stack[0]));
613 [ - + ]: 21306 : if (stack == NULL) {
614 : : PyErr_NoMemory();
615 : 0 : return NULL;
616 : : }
617 : : }
618 : :
619 : 2111697 : va_copy(lva, va);
620 : 2111697 : f = format;
621 : 2111697 : res = do_mkstack(stack, &f, &lva, '\0', n, flags);
622 : 2111697 : va_end(lva);
623 : :
624 [ - + ]: 2111697 : if (res < 0) {
625 [ # # ]: 0 : if (stack != small_stack) {
626 : 0 : PyMem_Free(stack);
627 : : }
628 : 0 : return NULL;
629 : : }
630 : :
631 : 2111697 : *p_nargs = n;
632 : 2111697 : return stack;
633 : : }
634 : :
635 : :
636 : : int
637 : 2172482 : PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value)
638 : : {
639 [ - + ]: 2172482 : if (!PyModule_Check(mod)) {
640 : 0 : PyErr_SetString(PyExc_TypeError,
641 : : "PyModule_AddObjectRef() first argument "
642 : : "must be a module");
643 : 0 : return -1;
644 : : }
645 [ - + ]: 2172482 : if (!value) {
646 [ # # ]: 0 : if (!PyErr_Occurred()) {
647 : 0 : PyErr_SetString(PyExc_SystemError,
648 : : "PyModule_AddObjectRef() must be called "
649 : : "with an exception raised if value is NULL");
650 : : }
651 : 0 : return -1;
652 : : }
653 : :
654 : 2172482 : PyObject *dict = PyModule_GetDict(mod);
655 [ - + ]: 2172482 : if (dict == NULL) {
656 : : /* Internal error -- modules must have a dict! */
657 : 0 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
658 : : PyModule_GetName(mod));
659 : 0 : return -1;
660 : : }
661 : :
662 [ - + ]: 2172482 : if (PyDict_SetItemString(dict, name, value)) {
663 : 0 : return -1;
664 : : }
665 : 2172482 : return 0;
666 : : }
667 : :
668 : :
669 : : int
670 : 201953 : PyModule_AddObject(PyObject *mod, const char *name, PyObject *value)
671 : : {
672 : 201953 : int res = PyModule_AddObjectRef(mod, name, value);
673 [ + - ]: 201953 : if (res == 0) {
674 : 201953 : Py_DECREF(value);
675 : : }
676 : 201953 : return res;
677 : : }
678 : :
679 : : int
680 : 1616808 : PyModule_AddIntConstant(PyObject *m, const char *name, long value)
681 : : {
682 : 1616808 : PyObject *obj = PyLong_FromLong(value);
683 [ - + ]: 1616808 : if (!obj) {
684 : 0 : return -1;
685 : : }
686 : 1616808 : int res = PyModule_AddObjectRef(m, name, obj);
687 : 1616808 : Py_DECREF(obj);
688 : 1616808 : return res;
689 : : }
690 : :
691 : : int
692 : 7569 : PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
693 : : {
694 : 7569 : PyObject *obj = PyUnicode_FromString(value);
695 [ - + ]: 7569 : if (!obj) {
696 : 0 : return -1;
697 : : }
698 : 7569 : int res = PyModule_AddObjectRef(m, name, obj);
699 : 7569 : Py_DECREF(obj);
700 : 7569 : return res;
701 : : }
702 : :
703 : : int
704 : 152237 : PyModule_AddType(PyObject *module, PyTypeObject *type)
705 : : {
706 [ - + ]: 152237 : if (PyType_Ready(type) < 0) {
707 : 0 : return -1;
708 : : }
709 : :
710 : 152237 : const char *name = _PyType_Name(type);
711 : : assert(name != NULL);
712 : :
713 : 152237 : return PyModule_AddObjectRef(module, name, (PyObject *)type);
714 : : }
|
