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