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