source: python/trunk/Python/modsupport.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 16.5 KB
RevLine 
[2]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,
[391]33 PyObject *passthrough, int module_api_version)
[2]34{
[391]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.
[2]50
[391]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;
[2]104}
105
106
107/* Helper for mkvalue() to scan the length of a format */
108
109static int
110countformat(const char *format, int endchar)
111{
[391]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;
[2]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{
[391]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;
[2]203}
204
205static PyObject *
206do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
207{
[391]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 }
[2]227
[391]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;
[2]242}
243
244#ifdef Py_USING_UNICODE
245static int
246_ustrlen(Py_UNICODE *u)
247{
[391]248 int i = 0;
249 Py_UNICODE *v = u;
250 while (*v != 0) { i++; v++; }
251 return i;
[2]252}
253#endif
254
255static PyObject *
256do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
257{
[391]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;
[2]290}
291
292static PyObject *
293do_mkvalue(const char **p_format, va_list *p_va, int flags)
294{
[391]295 for (;;) {
296 switch (*(*p_format)++) {
297 case '(':
298 return do_mktuple(p_format, p_va, ')',
299 countformat(*p_format, ')'), flags);
[2]300
[391]301 case '[':
302 return do_mklist(p_format, p_va, ']',
303 countformat(*p_format, ']'), flags);
[2]304
[391]305 case '{':
306 return do_mkdict(p_format, p_va, '}',
307 countformat(*p_format, '}'), flags);
[2]308
[391]309 case 'b':
310 case 'B':
311 case 'h':
312 case 'i':
313 return PyInt_FromLong((long)va_arg(*p_va, int));
[2]314
[391]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':
[2]329#if SIZEOF_SIZE_T!=SIZEOF_LONG
[391]330 return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
[2]331#endif
[391]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));
[2]335
[391]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 }
[2]345
346#ifdef HAVE_LONG_LONG
[391]347 case 'L':
348 return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
[2]349
[391]350 case 'K':
351 return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
[2]352#endif
353#ifdef Py_USING_UNICODE
[391]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 }
[2]379#endif
[391]380 case 'f':
381 case 'd':
382 return PyFloat_FromDouble(
383 (double)va_arg(*p_va, va_double));
[2]384
385#ifndef WITHOUT_COMPLEX
[391]386 case 'D':
387 return PyComplex_FromCComplex(
388 *((Py_complex *)va_arg(*p_va, Py_complex *)));
[2]389#endif /* WITHOUT_COMPLEX */
390
[391]391 case 'c':
392 {
393 char p[1];
394 p[0] = (char)va_arg(*p_va, int);
395 return PyString_FromStringAndSize(p, 1);
396 }
[2]397
[391]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 }
[2]431
[391]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 }
[2]462
[391]463 case ':':
464 case ',':
465 case ' ':
466 case '\t':
467 break;
[2]468
[391]469 default:
470 PyErr_SetString(PyExc_SystemError,
471 "bad format char passed to Py_BuildValue");
472 return NULL;
[2]473
[391]474 }
475 }
[2]476}
477
478
479PyObject *
480Py_BuildValue(const char *format, ...)
481{
[391]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;
[2]488}
489
490PyObject *
491_Py_BuildValue_SizeT(const char *format, ...)
492{
[391]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;
[2]499}
500
501PyObject *
502Py_VaBuildValue(const char *format, va_list va)
503{
[391]504 return va_build_value(format, va, 0);
[2]505}
506
507PyObject *
508_Py_VaBuildValue_SizeT(const char *format, va_list va)
509{
[391]510 return va_build_value(format, va, FLAG_SIZE_T);
[2]511}
512
513static PyObject *
514va_build_value(const char *format, va_list va, int flags)
515{
[391]516 const char *f = format;
517 int n = countformat(f, '\0');
518 va_list lva;
[2]519
520#ifdef VA_LIST_IS_ARRAY
[391]521 memcpy(lva, va, sizeof(va_list));
[2]522#else
523#ifdef __va_copy
[391]524 __va_copy(lva, va);
[2]525#else
[391]526 lva = va;
[2]527#endif
528#endif
529
[391]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);
[2]539}
540
541
542PyObject *
543PyEval_CallFunction(PyObject *obj, const char *format, ...)
544{
[391]545 va_list vargs;
546 PyObject *args;
547 PyObject *res;
[2]548
[391]549 va_start(vargs, format);
[2]550
[391]551 args = Py_VaBuildValue(format, vargs);
552 va_end(vargs);
[2]553
[391]554 if (args == NULL)
555 return NULL;
[2]556
[391]557 res = PyEval_CallObject(obj, args);
558 Py_DECREF(args);
[2]559
[391]560 return res;
[2]561}
562
563
564PyObject *
565PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
566{
[391]567 va_list vargs;
568 PyObject *meth;
569 PyObject *args;
570 PyObject *res;
[2]571
[391]572 meth = PyObject_GetAttrString(obj, methodname);
573 if (meth == NULL)
574 return NULL;
[2]575
[391]576 va_start(vargs, format);
[2]577
[391]578 args = Py_VaBuildValue(format, vargs);
579 va_end(vargs);
[2]580
[391]581 if (args == NULL) {
582 Py_DECREF(meth);
583 return NULL;
584 }
[2]585
[391]586 res = PyEval_CallObject(meth, args);
587 Py_DECREF(meth);
588 Py_DECREF(args);
[2]589
[391]590 return res;
[2]591}
592
593int
594PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
595{
[391]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 }
[2]608
[391]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;
[2]620}
621
[391]622int
[2]623PyModule_AddIntConstant(PyObject *m, const char *name, long value)
624{
[391]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;
[2]632}
633
[391]634int
[2]635PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
636{
[391]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;
[2]644}
Note: See TracBrowser for help on using the repository browser.