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