No issues found
1 /* Module support implementation */
2
3 #include "Python.h"
4
5 #define FLAG_SIZE_T 1
6 typedef double va_double;
7
8 static PyObject *va_build_value(const char *, va_list, int);
9
10 /* Package context -- the full module name for package imports */
11 char *_Py_PackageContext = NULL;
12
13 /* Py_InitModule4() parameters:
14 - name is the module name
15 - methods is the list of top-level functions
16 - doc is the documentation string
17 - passthrough is passed as self to functions defined in the module
18 - api_version is the value of PYTHON_API_VERSION at the time the
19 module was compiled
20
21 Return value is a borrowed reference to the module object; or NULL
22 if an error occurred (in Python 1.4 and before, errors were fatal).
23 Errors may still leak memory.
24 */
25
26 static char api_version_warning[] =
27 "Python C API version mismatch for module %.100s:\
28 This Python has API version %d, module %.100s has version %d.";
29
30 PyObject *
31 Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
32 PyObject *passthrough, int module_api_version)
33 {
34 PyObject *m, *d, *v, *n;
35 PyMethodDef *ml;
36 PyInterpreterState *interp = PyThreadState_Get()->interp;
37 if (interp->modules == NULL)
38 Py_FatalError("Python import machinery not initialized");
39 if (module_api_version != PYTHON_API_VERSION) {
40 char message[512];
41 PyOS_snprintf(message, sizeof(message),
42 api_version_warning, name,
43 PYTHON_API_VERSION, name,
44 module_api_version);
45 if (PyErr_Warn(PyExc_RuntimeWarning, message))
46 return NULL;
47 }
48 /* Make sure name is fully qualified.
49
50 This is a bit of a hack: when the shared library is loaded,
51 the module name is "package.module", but the module calls
52 Py_InitModule*() with just "module" for the name. The shared
53 library loader squirrels away the true name of the module in
54 _Py_PackageContext, and Py_InitModule*() will substitute this
55 (if the name actually matches).
56 */
57 if (_Py_PackageContext != NULL) {
58 char *p = strrchr(_Py_PackageContext, '.');
59 if (p != NULL && strcmp(name, p+1) == 0) {
60 name = _Py_PackageContext;
61 _Py_PackageContext = NULL;
62 }
63 }
64 if ((m = PyImport_AddModule(name)) == NULL)
65 return NULL;
66 d = PyModule_GetDict(m);
67 if (methods != NULL) {
68 n = PyString_FromString(name);
69 if (n == NULL)
70 return NULL;
71 for (ml = methods; ml->ml_name != NULL; ml++) {
72 if ((ml->ml_flags & METH_CLASS) ||
73 (ml->ml_flags & METH_STATIC)) {
74 PyErr_SetString(PyExc_ValueError,
75 "module functions cannot set"
76 " METH_CLASS or METH_STATIC");
77 Py_DECREF(n);
78 return NULL;
79 }
80 v = PyCFunction_NewEx(ml, passthrough, n);
81 if (v == NULL) {
82 Py_DECREF(n);
83 return NULL;
84 }
85 if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
86 Py_DECREF(v);
87 Py_DECREF(n);
88 return NULL;
89 }
90 Py_DECREF(v);
91 }
92 Py_DECREF(n);
93 }
94 if (doc != NULL) {
95 v = PyString_FromString(doc);
96 if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
97 Py_XDECREF(v);
98 return NULL;
99 }
100 Py_DECREF(v);
101 }
102 return m;
103 }
104
105
106 /* Helper for mkvalue() to scan the length of a format */
107
108 static int
109 countformat(const char *format, int endchar)
110 {
111 int count = 0;
112 int level = 0;
113 while (level > 0 || *format != endchar) {
114 switch (*format) {
115 case '\0':
116 /* Premature end */
117 PyErr_SetString(PyExc_SystemError,
118 "unmatched paren in format");
119 return -1;
120 case '(':
121 case '[':
122 case '{':
123 if (level == 0)
124 count++;
125 level++;
126 break;
127 case ')':
128 case ']':
129 case '}':
130 level--;
131 break;
132 case '#':
133 case '&':
134 case ',':
135 case ':':
136 case ' ':
137 case '\t':
138 break;
139 default:
140 if (level == 0)
141 count++;
142 }
143 format++;
144 }
145 return count;
146 }
147
148
149 /* Generic function to create a value -- the inverse of getargs() */
150 /* After an original idea and first implementation by Steven Miale */
151
152 static PyObject *do_mktuple(const char**, va_list *, int, int, int);
153 static PyObject *do_mklist(const char**, va_list *, int, int, int);
154 static PyObject *do_mkdict(const char**, va_list *, int, int, int);
155 static PyObject *do_mkvalue(const char**, va_list *, int);
156
157
158 static PyObject *
159 do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
160 {
161 PyObject *d;
162 int i;
163 int itemfailed = 0;
164 if (n < 0)
165 return NULL;
166 if ((d = PyDict_New()) == NULL)
167 return NULL;
168 /* Note that we can't bail immediately on error as this will leak
169 refcounts on any 'N' arguments. */
170 for (i = 0; i < n; i+= 2) {
171 PyObject *k, *v;
172 int err;
173 k = do_mkvalue(p_format, p_va, flags);
174 if (k == NULL) {
175 itemfailed = 1;
176 Py_INCREF(Py_None);
177 k = Py_None;
178 }
179 v = do_mkvalue(p_format, p_va, flags);
180 if (v == NULL) {
181 itemfailed = 1;
182 Py_INCREF(Py_None);
183 v = Py_None;
184 }
185 err = PyDict_SetItem(d, k, v);
186 Py_DECREF(k);
187 Py_DECREF(v);
188 if (err < 0 || itemfailed) {
189 Py_DECREF(d);
190 return NULL;
191 }
192 }
193 if (d != NULL && **p_format != endchar) {
194 Py_DECREF(d);
195 d = NULL;
196 PyErr_SetString(PyExc_SystemError,
197 "Unmatched paren in format");
198 }
199 else if (endchar)
200 ++*p_format;
201 return d;
202 }
203
204 static PyObject *
205 do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
206 {
207 PyObject *v;
208 int i;
209 int itemfailed = 0;
210 if (n < 0)
211 return NULL;
212 v = PyList_New(n);
213 if (v == NULL)
214 return NULL;
215 /* Note that we can't bail immediately on error as this will leak
216 refcounts on any 'N' arguments. */
217 for (i = 0; i < n; i++) {
218 PyObject *w = do_mkvalue(p_format, p_va, flags);
219 if (w == NULL) {
220 itemfailed = 1;
221 Py_INCREF(Py_None);
222 w = Py_None;
223 }
224 PyList_SET_ITEM(v, i, w);
225 }
226
227 if (itemfailed) {
228 /* do_mkvalue() should have already set an error */
229 Py_DECREF(v);
230 return NULL;
231 }
232 if (**p_format != endchar) {
233 Py_DECREF(v);
234 PyErr_SetString(PyExc_SystemError,
235 "Unmatched paren in format");
236 return NULL;
237 }
238 if (endchar)
239 ++*p_format;
240 return v;
241 }
242
243 #ifdef Py_USING_UNICODE
244 static int
245 _ustrlen(Py_UNICODE *u)
246 {
247 int i = 0;
248 Py_UNICODE *v = u;
249 while (*v != 0) { i++; v++; }
250 return i;
251 }
252 #endif
253
254 static PyObject *
255 do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
256 {
257 PyObject *v;
258 int i;
259 int itemfailed = 0;
260 if (n < 0)
261 return NULL;
262 if ((v = PyTuple_New(n)) == NULL)
263 return NULL;
264 /* Note that we can't bail immediately on error as this will leak
265 refcounts on any 'N' arguments. */
266 for (i = 0; i < n; i++) {
267 PyObject *w = do_mkvalue(p_format, p_va, flags);
268 if (w == NULL) {
269 itemfailed = 1;
270 Py_INCREF(Py_None);
271 w = Py_None;
272 }
273 PyTuple_SET_ITEM(v, i, w);
274 }
275 if (itemfailed) {
276 /* do_mkvalue() should have already set an error */
277 Py_DECREF(v);
278 return NULL;
279 }
280 if (**p_format != endchar) {
281 Py_DECREF(v);
282 PyErr_SetString(PyExc_SystemError,
283 "Unmatched paren in format");
284 return NULL;
285 }
286 if (endchar)
287 ++*p_format;
288 return v;
289 }
290
291 static PyObject *
292 do_mkvalue(const char **p_format, va_list *p_va, int flags)
293 {
294 for (;;) {
295 switch (*(*p_format)++) {
296 case '(':
297 return do_mktuple(p_format, p_va, ')',
298 countformat(*p_format, ')'), flags);
299
300 case '[':
301 return do_mklist(p_format, p_va, ']',
302 countformat(*p_format, ']'), flags);
303
304 case '{':
305 return do_mkdict(p_format, p_va, '}',
306 countformat(*p_format, '}'), flags);
307
308 case 'b':
309 case 'B':
310 case 'h':
311 case 'i':
312 return PyInt_FromLong((long)va_arg(*p_va, int));
313
314 case 'H':
315 return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
316
317 case 'I':
318 {
319 unsigned int n;
320 n = va_arg(*p_va, unsigned int);
321 if (n > (unsigned long)PyInt_GetMax())
322 return PyLong_FromUnsignedLong((unsigned long)n);
323 else
324 return PyInt_FromLong(n);
325 }
326
327 case 'n':
328 #if SIZEOF_SIZE_T!=SIZEOF_LONG
329 return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
330 #endif
331 /* Fall through from 'n' to 'l' if Py_ssize_t is long */
332 case 'l':
333 return PyInt_FromLong(va_arg(*p_va, long));
334
335 case 'k':
336 {
337 unsigned long n;
338 n = va_arg(*p_va, unsigned long);
339 if (n > (unsigned long)PyInt_GetMax())
340 return PyLong_FromUnsignedLong(n);
341 else
342 return PyInt_FromLong(n);
343 }
344
345 #ifdef HAVE_LONG_LONG
346 case 'L':
347 return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
348
349 case 'K':
350 return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
351 #endif
352 #ifdef Py_USING_UNICODE
353 case 'u':
354 {
355 PyObject *v;
356 Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
357 Py_ssize_t n;
358 if (**p_format == '#') {
359 ++*p_format;
360 if (flags & FLAG_SIZE_T)
361 n = va_arg(*p_va, Py_ssize_t);
362 else
363 n = va_arg(*p_va, int);
364 }
365 else
366 n = -1;
367 if (u == NULL) {
368 v = Py_None;
369 Py_INCREF(v);
370 }
371 else {
372 if (n < 0)
373 n = _ustrlen(u);
374 v = PyUnicode_FromUnicode(u, n);
375 }
376 return v;
377 }
378 #endif
379 case 'f':
380 case 'd':
381 return PyFloat_FromDouble(
382 (double)va_arg(*p_va, va_double));
383
384 #ifndef WITHOUT_COMPLEX
385 case 'D':
386 return PyComplex_FromCComplex(
387 *((Py_complex *)va_arg(*p_va, Py_complex *)));
388 #endif /* WITHOUT_COMPLEX */
389
390 case 'c':
391 {
392 char p[1];
393 p[0] = (char)va_arg(*p_va, int);
394 return PyString_FromStringAndSize(p, 1);
395 }
396
397 case 's':
398 case 'z':
399 {
400 PyObject *v;
401 char *str = va_arg(*p_va, char *);
402 Py_ssize_t n;
403 if (**p_format == '#') {
404 ++*p_format;
405 if (flags & FLAG_SIZE_T)
406 n = va_arg(*p_va, Py_ssize_t);
407 else
408 n = va_arg(*p_va, int);
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 = PyString_FromStringAndSize(str, n);
427 }
428 return v;
429 }
430
431 case 'N':
432 case 'S':
433 case 'O':
434 if (**p_format == '&') {
435 typedef PyObject *(*converter)(void *);
436 converter func = va_arg(*p_va, converter);
437 void *arg = va_arg(*p_va, void *);
438 ++*p_format;
439 return (*func)(arg);
440 }
441 else {
442 PyObject *v;
443 v = va_arg(*p_va, PyObject *);
444 if (v != NULL) {
445 if (*(*p_format - 1) != 'N')
446 Py_INCREF(v);
447 }
448 else if (!PyErr_Occurred())
449 /* If a NULL was passed
450 * because a call that should
451 * have constructed a value
452 * failed, that's OK, and we
453 * pass the error on; but if
454 * no error occurred it's not
455 * clear that the caller knew
456 * what she was doing. */
457 PyErr_SetString(PyExc_SystemError,
458 "NULL object passed to Py_BuildValue");
459 return v;
460 }
461
462 case ':':
463 case ',':
464 case ' ':
465 case '\t':
466 break;
467
468 default:
469 PyErr_SetString(PyExc_SystemError,
470 "bad format char passed to Py_BuildValue");
471 return NULL;
472
473 }
474 }
475 }
476
477
478 PyObject *
479 Py_BuildValue(const char *format, ...)
480 {
481 va_list va;
482 PyObject* retval;
483 va_start(va, format);
484 retval = va_build_value(format, va, 0);
485 va_end(va);
486 return retval;
487 }
488
489 PyObject *
490 _Py_BuildValue_SizeT(const char *format, ...)
491 {
492 va_list va;
493 PyObject* retval;
494 va_start(va, format);
495 retval = va_build_value(format, va, FLAG_SIZE_T);
496 va_end(va);
497 return retval;
498 }
499
500 PyObject *
501 Py_VaBuildValue(const char *format, va_list va)
502 {
503 return va_build_value(format, va, 0);
504 }
505
506 PyObject *
507 _Py_VaBuildValue_SizeT(const char *format, va_list va)
508 {
509 return va_build_value(format, va, FLAG_SIZE_T);
510 }
511
512 static PyObject *
513 va_build_value(const char *format, va_list va, int flags)
514 {
515 const char *f = format;
516 int n = countformat(f, '\0');
517 va_list lva;
518
519 #ifdef VA_LIST_IS_ARRAY
520 memcpy(lva, va, sizeof(va_list));
521 #else
522 #ifdef __va_copy
523 __va_copy(lva, va);
524 #else
525 lva = va;
526 #endif
527 #endif
528
529 if (n < 0)
530 return NULL;
531 if (n == 0) {
532 Py_INCREF(Py_None);
533 return Py_None;
534 }
535 if (n == 1)
536 return do_mkvalue(&f, &lva, flags);
537 return do_mktuple(&f, &lva, '\0', n, flags);
538 }
539
540
541 PyObject *
542 PyEval_CallFunction(PyObject *obj, const char *format, ...)
543 {
544 va_list vargs;
545 PyObject *args;
546 PyObject *res;
547
548 va_start(vargs, format);
549
550 args = Py_VaBuildValue(format, vargs);
551 va_end(vargs);
552
553 if (args == NULL)
554 return NULL;
555
556 res = PyEval_CallObject(obj, args);
557 Py_DECREF(args);
558
559 return res;
560 }
561
562
563 PyObject *
564 PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
565 {
566 va_list vargs;
567 PyObject *meth;
568 PyObject *args;
569 PyObject *res;
570
571 meth = PyObject_GetAttrString(obj, methodname);
572 if (meth == NULL)
573 return NULL;
574
575 va_start(vargs, format);
576
577 args = Py_VaBuildValue(format, vargs);
578 va_end(vargs);
579
580 if (args == NULL) {
581 Py_DECREF(meth);
582 return NULL;
583 }
584
585 res = PyEval_CallObject(meth, args);
586 Py_DECREF(meth);
587 Py_DECREF(args);
588
589 return res;
590 }
591
592 int
593 PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
594 {
595 PyObject *dict;
596 if (!PyModule_Check(m)) {
597 PyErr_SetString(PyExc_TypeError,
598 "PyModule_AddObject() needs module as first arg");
599 return -1;
600 }
601 if (!o) {
602 if (!PyErr_Occurred())
603 PyErr_SetString(PyExc_TypeError,
604 "PyModule_AddObject() needs non-NULL value");
605 return -1;
606 }
607
608 dict = PyModule_GetDict(m);
609 if (dict == NULL) {
610 /* Internal error -- modules must have a dict! */
611 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
612 PyModule_GetName(m));
613 return -1;
614 }
615 if (PyDict_SetItemString(dict, name, o))
616 return -1;
617 Py_DECREF(o);
618 return 0;
619 }
620
621 int
622 PyModule_AddIntConstant(PyObject *m, const char *name, long value)
623 {
624 PyObject *o = PyInt_FromLong(value);
625 if (!o)
626 return -1;
627 if (PyModule_AddObject(m, name, o) == 0)
628 return 0;
629 Py_DECREF(o);
630 return -1;
631 }
632
633 int
634 PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
635 {
636 PyObject *o = PyString_FromString(value);
637 if (!o)
638 return -1;
639 if (PyModule_AddObject(m, name, o) == 0)
640 return 0;
641 Py_DECREF(o);
642 return -1;
643 }