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 PyObject *
do_mkdict(const char ** p_format,va_list * p_va,int endchar,int n,int flags)160 do_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 
205 static PyObject *
do_mklist(const char ** p_format,va_list * p_va,int endchar,int n,int flags)206 do_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
245 static int
_ustrlen(Py_UNICODE * u)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 
255 static PyObject *
do_mktuple(const char ** p_format,va_list * p_va,int endchar,int n,int flags)256 do_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 
292 static PyObject *
do_mkvalue(const char ** p_format,va_list * p_va,int flags)293 do_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 
479 PyObject *
Py_BuildValue(const char * format,...)480 Py_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 
490 PyObject *
_Py_BuildValue_SizeT(const char * format,...)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 
501 PyObject *
Py_VaBuildValue(const char * format,va_list va)502 Py_VaBuildValue(const char *format, va_list va)
503 {
504     return va_build_value(format, va, 0);
505 }
506 
507 PyObject *
_Py_VaBuildValue_SizeT(const char * format,va_list va)508 _Py_VaBuildValue_SizeT(const char *format, va_list va)
509 {
510     return va_build_value(format, va, FLAG_SIZE_T);
511 }
512 
513 static PyObject *
va_build_value(const char * format,va_list va,int flags)514 va_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 
542 PyObject *
PyEval_CallFunction(PyObject * obj,const char * format,...)543 PyEval_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 
564 PyObject *
PyEval_CallMethod(PyObject * obj,const char * methodname,const char * format,...)565 PyEval_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 
593 int
PyModule_AddObject(PyObject * m,const char * name,PyObject * o)594 PyModule_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 
622 int
PyModule_AddIntConstant(PyObject * m,const char * name,long value)623 PyModule_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 
634 int
PyModule_AddStringConstant(PyObject * m,const char * name,const char * value)635 PyModule_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 }
645