1 
2 /* Module support implementation */
3 
4 #include "Python.h"
5 
6 #define FLAG_SIZE_T 1
7 typedef double va_double;
8 
9 static PyObject *va_build_value(const char *, va_list, int);
10 
11 /* Package context -- the full module name for package imports */
12 char *_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 
27 static 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 
31 PyObject *
Py_InitModule4(const char * name,PyMethodDef * methods,const char * doc,PyObject * passthrough,int module_api_version)32 Py_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 
109 static int
countformat(const char * format,int endchar)110 countformat(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 
153 static PyObject *do_mktuple(const char**, va_list *, int, int, int);
154 static PyObject *do_mklist(const char**, va_list *, int, int, int);
155 static PyObject *do_mkdict(const char**, va_list *, int, int, int);
156 static PyObject *do_mkvalue(const char**, va_list *, int);
157 
158 
159 static void
do_ignore(const char ** p_format,va_list * p_va,int endchar,int n,int flags)160 do_ignore(const char **p_format, va_list *p_va, int endchar, int n, int flags)
161 {
162     PyObject *v;
163     int i;
164     assert(PyErr_Occurred());
165     v = PyTuple_New(n);
166     for (i = 0; i < n; i++) {
167         PyObject *exception, *value, *tb, *w;
168         PyErr_Fetch(&exception, &value, &tb);
169         w = do_mkvalue(p_format, p_va, flags);
170         PyErr_Restore(exception, value, tb);
171         if (w != NULL) {
172             if (v != NULL) {
173                 PyTuple_SET_ITEM(v, i, w);
174             }
175             else {
176                 Py_DECREF(w);
177             }
178         }
179     }
180     Py_XDECREF(v);
181     if (**p_format != endchar) {
182         PyErr_SetString(PyExc_SystemError,
183                         "Unmatched paren in format");
184         return;
185     }
186     if (endchar)
187         ++*p_format;
188 }
189 
190 static PyObject *
do_mkdict(const char ** p_format,va_list * p_va,int endchar,int n,int flags)191 do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
192 {
193     PyObject *d;
194     int i;
195     if (n < 0)
196         return NULL;
197     if (n % 2) {
198         PyErr_SetString(PyExc_SystemError,
199                         "Bad dict format");
200         do_ignore(p_format, p_va, endchar, n, flags);
201         return NULL;
202     }
203     /* Note that we can't bail immediately on error as this will leak
204        refcounts on any 'N' arguments. */
205     if ((d = PyDict_New()) == NULL) {
206         do_ignore(p_format, p_va, endchar, n, flags);
207         return NULL;
208     }
209     for (i = 0; i < n; i+= 2) {
210         PyObject *k, *v;
211 
212         k = do_mkvalue(p_format, p_va, flags);
213         if (k == NULL) {
214             do_ignore(p_format, p_va, endchar, n - i - 1, flags);
215             Py_DECREF(d);
216             return NULL;
217         }
218         v = do_mkvalue(p_format, p_va, flags);
219         if (v == NULL || PyDict_SetItem(d, k, v) < 0) {
220             do_ignore(p_format, p_va, endchar, n - i - 2, flags);
221             Py_DECREF(k);
222             Py_XDECREF(v);
223             Py_DECREF(d);
224             return NULL;
225         }
226         Py_DECREF(k);
227         Py_DECREF(v);
228     }
229     if (**p_format != endchar) {
230         Py_DECREF(d);
231         PyErr_SetString(PyExc_SystemError,
232                         "Unmatched paren in format");
233         return NULL;
234     }
235     if (endchar)
236         ++*p_format;
237     return d;
238 }
239 
240 static PyObject *
do_mklist(const char ** p_format,va_list * p_va,int endchar,int n,int flags)241 do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
242 {
243     PyObject *v;
244     int i;
245     if (n < 0)
246         return NULL;
247     /* Note that we can't bail immediately on error as this will leak
248        refcounts on any 'N' arguments. */
249     v = PyList_New(n);
250     if (v == NULL) {
251         do_ignore(p_format, p_va, endchar, n, flags);
252         return NULL;
253     }
254     for (i = 0; i < n; i++) {
255         PyObject *w = do_mkvalue(p_format, p_va, flags);
256         if (w == NULL) {
257             do_ignore(p_format, p_va, endchar, n - i - 1, flags);
258             Py_DECREF(v);
259             return NULL;
260         }
261         PyList_SET_ITEM(v, i, w);
262     }
263     if (**p_format != endchar) {
264         Py_DECREF(v);
265         PyErr_SetString(PyExc_SystemError,
266                         "Unmatched paren in format");
267         return NULL;
268     }
269     if (endchar)
270         ++*p_format;
271     return v;
272 }
273 
274 #ifdef Py_USING_UNICODE
275 static int
_ustrlen(Py_UNICODE * u)276 _ustrlen(Py_UNICODE *u)
277 {
278     int i = 0;
279     Py_UNICODE *v = u;
280     while (*v != 0) { i++; v++; }
281     return i;
282 }
283 #endif
284 
285 static PyObject *
do_mktuple(const char ** p_format,va_list * p_va,int endchar,int n,int flags)286 do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
287 {
288     PyObject *v;
289     int i;
290     if (n < 0)
291         return NULL;
292     /* Note that we can't bail immediately on error as this will leak
293        refcounts on any 'N' arguments. */
294     if ((v = PyTuple_New(n)) == NULL) {
295         do_ignore(p_format, p_va, endchar, n, flags);
296         return NULL;
297     }
298     for (i = 0; i < n; i++) {
299         PyObject *w = do_mkvalue(p_format, p_va, flags);
300         if (w == NULL) {
301             do_ignore(p_format, p_va, endchar, n - i - 1, flags);
302             Py_DECREF(v);
303             return NULL;
304         }
305         PyTuple_SET_ITEM(v, i, w);
306     }
307     if (**p_format != endchar) {
308         Py_DECREF(v);
309         PyErr_SetString(PyExc_SystemError,
310                         "Unmatched paren in format");
311         return NULL;
312     }
313     if (endchar)
314         ++*p_format;
315     return v;
316 }
317 
318 static PyObject *
do_mkvalue(const char ** p_format,va_list * p_va,int flags)319 do_mkvalue(const char **p_format, va_list *p_va, int flags)
320 {
321     for (;;) {
322         switch (*(*p_format)++) {
323         case '(':
324             return do_mktuple(p_format, p_va, ')',
325                               countformat(*p_format, ')'), flags);
326 
327         case '[':
328             return do_mklist(p_format, p_va, ']',
329                              countformat(*p_format, ']'), flags);
330 
331         case '{':
332             return do_mkdict(p_format, p_va, '}',
333                              countformat(*p_format, '}'), flags);
334 
335         case 'b':
336         case 'B':
337         case 'h':
338         case 'i':
339             return PyInt_FromLong((long)va_arg(*p_va, int));
340 
341         case 'H':
342             return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
343 
344         case 'I':
345         {
346             unsigned int n;
347             n = va_arg(*p_va, unsigned int);
348             if (n > (unsigned long)PyInt_GetMax())
349                 return PyLong_FromUnsignedLong((unsigned long)n);
350             else
351                 return PyInt_FromLong(n);
352         }
353 
354         case 'n':
355 #if SIZEOF_SIZE_T!=SIZEOF_LONG
356             return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
357 #endif
358             /* Fall through from 'n' to 'l' if Py_ssize_t is long */
359         case 'l':
360             return PyInt_FromLong(va_arg(*p_va, long));
361 
362         case 'k':
363         {
364             unsigned long n;
365             n = va_arg(*p_va, unsigned long);
366             if (n > (unsigned long)PyInt_GetMax())
367                 return PyLong_FromUnsignedLong(n);
368             else
369                 return PyInt_FromLong(n);
370         }
371 
372 #ifdef HAVE_LONG_LONG
373         case 'L':
374             return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
375 
376         case 'K':
377             return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
378 #endif
379 #ifdef Py_USING_UNICODE
380         case 'u':
381         {
382             PyObject *v;
383             Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
384             Py_ssize_t n;
385             if (**p_format == '#') {
386                 ++*p_format;
387                 if (flags & FLAG_SIZE_T)
388                     n = va_arg(*p_va, Py_ssize_t);
389                 else
390                     n = va_arg(*p_va, int);
391             }
392             else
393                 n = -1;
394             if (u == NULL) {
395                 v = Py_None;
396                 Py_INCREF(v);
397             }
398             else {
399                 if (n < 0)
400                     n = _ustrlen(u);
401                 v = PyUnicode_FromUnicode(u, n);
402             }
403             return v;
404         }
405 #endif
406         case 'f':
407         case 'd':
408             return PyFloat_FromDouble(
409                 (double)va_arg(*p_va, va_double));
410 
411 #ifndef WITHOUT_COMPLEX
412         case 'D':
413             return PyComplex_FromCComplex(
414                 *((Py_complex *)va_arg(*p_va, Py_complex *)));
415 #endif /* WITHOUT_COMPLEX */
416 
417         case 'c':
418         {
419             char p[1];
420             p[0] = (char)va_arg(*p_va, int);
421             return PyString_FromStringAndSize(p, 1);
422         }
423 
424         case 's':
425         case 'z':
426         {
427             PyObject *v;
428             char *str = va_arg(*p_va, char *);
429             Py_ssize_t n;
430             if (**p_format == '#') {
431                 ++*p_format;
432                 if (flags & FLAG_SIZE_T)
433                     n = va_arg(*p_va, Py_ssize_t);
434                 else
435                     n = va_arg(*p_va, int);
436             }
437             else
438                 n = -1;
439             if (str == NULL) {
440                 v = Py_None;
441                 Py_INCREF(v);
442             }
443             else {
444                 if (n < 0) {
445                     size_t m = strlen(str);
446                     if (m > PY_SSIZE_T_MAX) {
447                         PyErr_SetString(PyExc_OverflowError,
448                             "string too long for Python string");
449                         return NULL;
450                     }
451                     n = (Py_ssize_t)m;
452                 }
453                 v = PyString_FromStringAndSize(str, n);
454             }
455             return v;
456         }
457 
458         case 'N':
459         case 'S':
460         case 'O':
461         if (**p_format == '&') {
462             typedef PyObject *(*converter)(void *);
463             converter func = va_arg(*p_va, converter);
464             void *arg = va_arg(*p_va, void *);
465             ++*p_format;
466             return (*func)(arg);
467         }
468         else {
469             PyObject *v;
470             v = va_arg(*p_va, PyObject *);
471             if (v != NULL) {
472                 if (*(*p_format - 1) != 'N')
473                     Py_INCREF(v);
474             }
475             else if (!PyErr_Occurred())
476                 /* If a NULL was passed
477                  * because a call that should
478                  * have constructed a value
479                  * failed, that's OK, and we
480                  * pass the error on; but if
481                  * no error occurred it's not
482                  * clear that the caller knew
483                  * what she was doing. */
484                 PyErr_SetString(PyExc_SystemError,
485                     "NULL object passed to Py_BuildValue");
486             return v;
487         }
488 
489         case ':':
490         case ',':
491         case ' ':
492         case '\t':
493             break;
494 
495         default:
496             PyErr_SetString(PyExc_SystemError,
497                 "bad format char passed to Py_BuildValue");
498             return NULL;
499 
500         }
501     }
502 }
503 
504 
505 PyObject *
Py_BuildValue(const char * format,...)506 Py_BuildValue(const char *format, ...)
507 {
508     va_list va;
509     PyObject* retval;
510     va_start(va, format);
511     retval = va_build_value(format, va, 0);
512     va_end(va);
513     return retval;
514 }
515 
516 PyObject *
_Py_BuildValue_SizeT(const char * format,...)517 _Py_BuildValue_SizeT(const char *format, ...)
518 {
519     va_list va;
520     PyObject* retval;
521     va_start(va, format);
522     retval = va_build_value(format, va, FLAG_SIZE_T);
523     va_end(va);
524     return retval;
525 }
526 
527 PyObject *
Py_VaBuildValue(const char * format,va_list va)528 Py_VaBuildValue(const char *format, va_list va)
529 {
530     return va_build_value(format, va, 0);
531 }
532 
533 PyObject *
_Py_VaBuildValue_SizeT(const char * format,va_list va)534 _Py_VaBuildValue_SizeT(const char *format, va_list va)
535 {
536     return va_build_value(format, va, FLAG_SIZE_T);
537 }
538 
539 static PyObject *
va_build_value(const char * format,va_list va,int flags)540 va_build_value(const char *format, va_list va, int flags)
541 {
542     const char *f = format;
543     int n = countformat(f, '\0');
544     va_list lva;
545 
546 #ifdef VA_LIST_IS_ARRAY
547     memcpy(lva, va, sizeof(va_list));
548 #else
549 #ifdef __va_copy
550     __va_copy(lva, va);
551 #else
552     lva = va;
553 #endif
554 #endif
555 
556     if (n < 0)
557         return NULL;
558     if (n == 0) {
559         Py_INCREF(Py_None);
560         return Py_None;
561     }
562     if (n == 1)
563         return do_mkvalue(&f, &lva, flags);
564     return do_mktuple(&f, &lva, '\0', n, flags);
565 }
566 
567 
568 PyObject *
PyEval_CallFunction(PyObject * obj,const char * format,...)569 PyEval_CallFunction(PyObject *obj, const char *format, ...)
570 {
571     va_list vargs;
572     PyObject *args;
573     PyObject *res;
574 
575     va_start(vargs, format);
576 
577     args = Py_VaBuildValue(format, vargs);
578     va_end(vargs);
579 
580     if (args == NULL)
581         return NULL;
582 
583     res = PyEval_CallObject(obj, args);
584     Py_DECREF(args);
585 
586     return res;
587 }
588 
589 
590 PyObject *
PyEval_CallMethod(PyObject * obj,const char * methodname,const char * format,...)591 PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
592 {
593     va_list vargs;
594     PyObject *meth;
595     PyObject *args;
596     PyObject *res;
597 
598     meth = PyObject_GetAttrString(obj, methodname);
599     if (meth == NULL)
600         return NULL;
601 
602     va_start(vargs, format);
603 
604     args = Py_VaBuildValue(format, vargs);
605     va_end(vargs);
606 
607     if (args == NULL) {
608         Py_DECREF(meth);
609         return NULL;
610     }
611 
612     res = PyEval_CallObject(meth, args);
613     Py_DECREF(meth);
614     Py_DECREF(args);
615 
616     return res;
617 }
618 
619 int
PyModule_AddObject(PyObject * m,const char * name,PyObject * o)620 PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
621 {
622     PyObject *dict;
623     if (!PyModule_Check(m)) {
624         PyErr_SetString(PyExc_TypeError,
625                     "PyModule_AddObject() needs module as first arg");
626         return -1;
627     }
628     if (!o) {
629         if (!PyErr_Occurred())
630             PyErr_SetString(PyExc_TypeError,
631                             "PyModule_AddObject() needs non-NULL value");
632         return -1;
633     }
634 
635     dict = PyModule_GetDict(m);
636     if (dict == NULL) {
637         /* Internal error -- modules must have a dict! */
638         PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
639                      PyModule_GetName(m));
640         return -1;
641     }
642     if (PyDict_SetItemString(dict, name, o))
643         return -1;
644     Py_DECREF(o);
645     return 0;
646 }
647 
648 int
PyModule_AddIntConstant(PyObject * m,const char * name,long value)649 PyModule_AddIntConstant(PyObject *m, const char *name, long value)
650 {
651     PyObject *o = PyInt_FromLong(value);
652     if (!o)
653         return -1;
654     if (PyModule_AddObject(m, name, o) == 0)
655         return 0;
656     Py_DECREF(o);
657     return -1;
658 }
659 
660 int
PyModule_AddStringConstant(PyObject * m,const char * name,const char * value)661 PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
662 {
663     PyObject *o = PyString_FromString(value);
664     if (!o)
665         return -1;
666     if (PyModule_AddObject(m, name, o) == 0)
667         return 0;
668     Py_DECREF(o);
669     return -1;
670 }
671