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 _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
43 static Py_ssize_t
44 countformat(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
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 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 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
129 static PyObject *
130 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 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
179 static PyObject *
180 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 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
213 static int
214 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 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
242 error:
243 n = i;
244 for (i=0; i < n; i++) {
245 Py_DECREF(stack[i]);
246 }
247 return -1;
248 }
249
250 static PyObject *
251 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 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
283 static PyObject *
284 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 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
516 PyObject *
517 Py_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
527 PyObject *
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
538 PyObject *
539 Py_VaBuildValue(const char *format, va_list va)
540 {
541 return va_build_value(format, va, 0);
542 }
543
544 PyObject *
545 _Py_VaBuildValue_SizeT(const char *format, va_list va)
546 {
547 return va_build_value(format, va, FLAG_SIZE_T);
548 }
549
550 static PyObject *
551 va_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
573 PyObject **
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
580 PyObject **
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
587 static PyObject **
588 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 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
636 int
637 PyModule_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 return PyDict_SetItemString(dict, name, value);
662 }
663
664 int
665 _PyModule_Add(PyObject *mod, const char *name, PyObject *value)
666 {
667 int res = PyModule_AddObjectRef(mod, name, value);
668 Py_XDECREF(value);
669 return res;
670 }
671
672 int
673 PyModule_AddObject(PyObject *mod, const char *name, PyObject *value)
674 {
675 int res = PyModule_AddObjectRef(mod, name, value);
676 if (res == 0) {
677 Py_DECREF(value);
678 }
679 return res;
680 }
681
682 int
683 PyModule_AddIntConstant(PyObject *m, const char *name, long value)
684 {
685 return _PyModule_Add(m, name, PyLong_FromLong(value));
686 }
687
688 int
689 PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
690 {
691 return _PyModule_Add(m, name, PyUnicode_FromString(value));
692 }
693
694 int
695 PyModule_AddType(PyObject *module, PyTypeObject *type)
696 {
697 if (PyType_Ready(type) < 0) {
698 return -1;
699 }
700
701 const char *name = _PyType_Name(type);
702 assert(name != NULL);
703
704 return PyModule_AddObjectRef(module, name, (PyObject *)type);
705 }