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 11998300 : _Py_convert_optional_to_ssize_t(PyObject *obj, void *result)
19 : {
20 : Py_ssize_t limit;
21 11998300 : if (obj == Py_None) {
22 107 : return 1;
23 : }
24 11998200 : else if (_PyIndex_Check(obj)) {
25 11998200 : limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError);
26 11998200 : 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 11998200 : *((Py_ssize_t *)result) = limit;
37 11998200 : return 1;
38 : }
39 :
40 :
41 : /* Helper for mkvalue() to scan the length of a format */
42 :
43 : static Py_ssize_t
44 14025800 : countformat(const char *format, char endchar)
45 : {
46 14025800 : Py_ssize_t count = 0;
47 14025800 : int level = 0;
48 60623900 : while (level > 0 || *format != endchar) {
49 46598100 : 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 3226590 : case '(':
56 : case '[':
57 : case '{':
58 3226590 : if (level == 0) {
59 3205670 : count++;
60 : }
61 3226590 : level++;
62 3226590 : break;
63 3226590 : case ')':
64 : case ']':
65 : case '}':
66 3226590 : level--;
67 3226590 : break;
68 5653760 : case '#':
69 : case '&':
70 : case ',':
71 : case ':':
72 : case ' ':
73 : case '\t':
74 5653760 : break;
75 34491100 : default:
76 34491100 : if (level == 0) {
77 25396200 : count++;
78 : }
79 : }
80 46598100 : format++;
81 : }
82 14025800 : 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 24 : 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 209660 : 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 209660 : if (n < 0)
135 0 : return NULL;
136 209660 : 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 209660 : if ((d = PyDict_New()) == NULL) {
145 0 : do_ignore(p_format, p_va, endchar, n, flags);
146 0 : return NULL;
147 : }
148 939848 : for (i = 0; i < n; i+= 2) {
149 : PyObject *k, *v;
150 :
151 730192 : k = do_mkvalue(p_format, p_va, flags);
152 730192 : 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 730190 : v = do_mkvalue(p_format, p_va, flags);
158 730190 : 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 730188 : Py_DECREF(k);
166 730188 : Py_DECREF(v);
167 : }
168 209656 : 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 209656 : if (endchar)
175 209656 : ++*p_format;
176 209656 : 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 2198990 : 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 2198990 : 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 9017060 : for (i = 0; i < n; i++) {
225 6818070 : PyObject *w = do_mkvalue(p_format, p_va, flags);
226 6818070 : if (w == NULL) {
227 0 : do_ignore(p_format, p_va, endchar, n - i - 1, flags);
228 0 : goto error;
229 : }
230 6818070 : stack[i] = w;
231 : }
232 2198990 : if (**p_format != endchar) {
233 0 : PyErr_SetString(PyExc_SystemError,
234 : "Unmatched paren in format");
235 0 : goto error;
236 : }
237 2198990 : if (endchar) {
238 0 : ++*p_format;
239 : }
240 2198990 : 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 6377950 : 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 6377950 : 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 6377950 : if ((v = PyTuple_New(n)) == NULL) {
260 0 : do_ignore(p_format, p_va, endchar, n, flags);
261 0 : return NULL;
262 : }
263 21462200 : for (i = 0; i < n; i++) {
264 15084200 : PyObject *w = do_mkvalue(p_format, p_va, flags);
265 15084200 : 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 15084200 : PyTuple_SET_ITEM(v, i, w);
271 : }
272 6377930 : 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 6377930 : if (endchar)
279 2996000 : ++*p_format;
280 6377930 : return v;
281 : }
282 :
283 : static PyObject *
284 28602300 : 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 28602300 : switch (*(*p_format)++) {
295 2996000 : case '(':
296 2996000 : 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 209660 : case '{':
304 209660 : return do_mkdict(p_format, p_va, '}',
305 : countformat(*p_format, '}'), flags);
306 :
307 5340440 : case 'b':
308 : case 'B':
309 : case 'h':
310 : case 'i':
311 5340440 : 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 45348 : case 'I':
317 : {
318 : unsigned int n;
319 45348 : n = va_arg(*p_va, unsigned int);
320 45348 : return PyLong_FromUnsignedLong(n);
321 : }
322 :
323 747174 : 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 747174 : return PyLong_FromLong(va_arg(*p_va, long));
330 :
331 986 : case 'k':
332 : {
333 : unsigned long n;
334 986 : n = va_arg(*p_va, unsigned long);
335 986 : 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 38328 : case 'K':
342 38328 : 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 534507 : case 'f':
373 : case 'd':
374 534507 : return PyFloat_FromDouble(
375 534507 : (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 58806 : case 'c':
382 : {
383 : char p[1];
384 58806 : p[0] = (char)va_arg(*p_va, int);
385 58806 : return PyBytes_FromStringAndSize(p, 1);
386 : }
387 72705 : case 'C':
388 : {
389 72705 : int i = va_arg(*p_va, int);
390 72705 : return PyUnicode_FromOrdinal(i);
391 : }
392 :
393 2429480 : case 's':
394 : case 'z':
395 : case 'U': /* XXX deprecated alias */
396 : {
397 : PyObject *v;
398 2429480 : const char *str = va_arg(*p_va, const char *);
399 : Py_ssize_t n;
400 2429480 : 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 2428940 : n = -1;
412 2429480 : if (str == NULL) {
413 23566 : v = Py_None;
414 23566 : Py_INCREF(v);
415 : }
416 : else {
417 2405910 : if (n < 0) {
418 2405370 : size_t m = strlen(str);
419 2405370 : 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 2405370 : n = (Py_ssize_t)m;
425 : }
426 2405910 : v = PyUnicode_FromStringAndSize(str, n);
427 : }
428 2429480 : return v;
429 : }
430 :
431 111222 : case 'y':
432 : {
433 : PyObject *v;
434 111222 : const char *str = va_arg(*p_va, const char *);
435 : Py_ssize_t n;
436 111222 : if (**p_format == '#') {
437 37049 : ++*p_format;
438 37049 : if (flags & FLAG_SIZE_T) {
439 37048 : 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 74173 : n = -1;
448 111221 : if (str == NULL) {
449 0 : v = Py_None;
450 0 : Py_INCREF(v);
451 : }
452 : else {
453 111221 : if (n < 0) {
454 74173 : size_t m = strlen(str);
455 74173 : 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 74173 : n = (Py_ssize_t)m;
461 : }
462 111221 : v = PyBytes_FromStringAndSize(str, n);
463 : }
464 111221 : return v;
465 : }
466 :
467 16017200 : case 'N':
468 : case 'S':
469 : case 'O':
470 16017200 : if (**p_format == '&') {
471 : typedef PyObject *(*converter)(void *);
472 2807670 : converter func = va_arg(*p_va, converter);
473 2807670 : void *arg = va_arg(*p_va, void *);
474 2807670 : ++*p_format;
475 2807670 : return (*func)(arg);
476 : }
477 : else {
478 : PyObject *v;
479 13209500 : v = va_arg(*p_va, PyObject *);
480 13209500 : if (v != NULL) {
481 13209500 : if (*(*p_format - 1) != 'N')
482 12183500 : 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 13209500 : return v;
496 : }
497 :
498 393 : case ':':
499 : case ',':
500 : case ' ':
501 : case '\t':
502 393 : 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 2845450 : Py_BuildValue(const char *format, ...)
518 : {
519 : va_list va;
520 : PyObject* retval;
521 2845450 : va_start(va, format);
522 2845450 : retval = va_build_value(format, va, 0);
523 2845450 : va_end(va);
524 2845450 : return retval;
525 : }
526 :
527 : PyObject *
528 1392570 : _Py_BuildValue_SizeT(const char *format, ...)
529 : {
530 : va_list va;
531 : PyObject* retval;
532 1392570 : va_start(va, format);
533 1392570 : retval = va_build_value(format, va, FLAG_SIZE_T);
534 1392570 : va_end(va);
535 1392570 : 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 4383130 : _Py_VaBuildValue_SizeT(const char *format, va_list va)
546 : {
547 4383130 : return va_build_value(format, va, FLAG_SIZE_T);
548 : }
549 :
550 : static PyObject *
551 8621150 : va_build_value(const char *format, va_list va, int flags)
552 : {
553 8621150 : const char *f = format;
554 8621150 : Py_ssize_t n = countformat(f, '\0');
555 : va_list lva;
556 : PyObject *retval;
557 :
558 8621150 : if (n < 0)
559 0 : return NULL;
560 8621150 : if (n == 0) {
561 0 : Py_RETURN_NONE;
562 : }
563 8621150 : va_copy(lva, va);
564 8621150 : if (n == 1) {
565 5239200 : retval = do_mkvalue(&f, &lva, flags);
566 : } else {
567 3381950 : retval = do_mktuple(&f, &lva, '\0', n, flags);
568 : }
569 8621150 : va_end(lva);
570 8621150 : return retval;
571 : }
572 :
573 : PyObject **
574 888627 : _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 888627 : return va_build_stack(small_stack, small_stack_len, format, va, 0, p_nargs);
578 : }
579 :
580 : PyObject **
581 1310360 : _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 1310360 : return va_build_stack(small_stack, small_stack_len, format, va, FLAG_SIZE_T, p_nargs);
585 : }
586 :
587 : static PyObject **
588 2198990 : 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 2198990 : n = countformat(format, '\0');
598 2198990 : if (n < 0) {
599 0 : *p_nargs = 0;
600 0 : return NULL;
601 : }
602 :
603 2198990 : if (n == 0) {
604 0 : *p_nargs = 0;
605 0 : return small_stack;
606 : }
607 :
608 2198990 : if (n <= small_stack_len) {
609 2177720 : stack = small_stack;
610 : }
611 : else {
612 21275 : stack = PyMem_Malloc(n * sizeof(stack[0]));
613 21275 : if (stack == NULL) {
614 0 : PyErr_NoMemory();
615 0 : return NULL;
616 : }
617 : }
618 :
619 2198990 : va_copy(lva, va);
620 2198990 : f = format;
621 2198990 : res = do_mkstack(stack, &f, &lva, '\0', n, flags);
622 2198990 : va_end(lva);
623 :
624 2198990 : if (res < 0) {
625 0 : if (stack != small_stack) {
626 0 : PyMem_Free(stack);
627 : }
628 0 : return NULL;
629 : }
630 :
631 2198990 : *p_nargs = n;
632 2198990 : return stack;
633 : }
634 :
635 :
636 : int
637 2170450 : PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value)
638 : {
639 2170450 : 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 2170450 : 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 2170450 : PyObject *dict = PyModule_GetDict(mod);
655 2170450 : 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 2170450 : if (PyDict_SetItemString(dict, name, value)) {
663 0 : return -1;
664 : }
665 2170450 : return 0;
666 : }
667 :
668 :
669 : int
670 208257 : PyModule_AddObject(PyObject *mod, const char *name, PyObject *value)
671 : {
672 208257 : int res = PyModule_AddObjectRef(mod, name, value);
673 208257 : if (res == 0) {
674 208257 : Py_DECREF(value);
675 : }
676 208257 : return res;
677 : }
678 :
679 : int
680 1612110 : PyModule_AddIntConstant(PyObject *m, const char *name, long value)
681 : {
682 1612110 : PyObject *obj = PyLong_FromLong(value);
683 1612110 : if (!obj) {
684 0 : return -1;
685 : }
686 1612110 : int res = PyModule_AddObjectRef(m, name, obj);
687 1612110 : Py_DECREF(obj);
688 1612110 : return res;
689 : }
690 :
691 : int
692 5906 : PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
693 : {
694 5906 : PyObject *obj = PyUnicode_FromString(value);
695 5906 : if (!obj) {
696 0 : return -1;
697 : }
698 5906 : int res = PyModule_AddObjectRef(m, name, obj);
699 5906 : Py_DECREF(obj);
700 5906 : return res;
701 : }
702 :
703 : int
704 148263 : PyModule_AddType(PyObject *module, PyTypeObject *type)
705 : {
706 148263 : if (PyType_Ready(type) < 0) {
707 0 : return -1;
708 : }
709 :
710 148263 : const char *name = _PyType_Name(type);
711 148263 : assert(name != NULL);
712 :
713 148263 : return PyModule_AddObjectRef(module, name, (PyObject *)type);
714 : }
|
