1991-02-19 08:39:46 -04:00
|
|
|
|
1990-10-14 09:07:46 -03:00
|
|
|
/* Module support implementation */
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
#include "Python.h"
|
1990-10-14 09:07:46 -03:00
|
|
|
|
2006-04-14 06:08:42 -03:00
|
|
|
#define FLAG_SIZE_T 1
|
1994-08-30 05:27:36 -03:00
|
|
|
typedef double va_double;
|
|
|
|
|
2006-04-14 06:08:42 -03:00
|
|
|
static PyObject *va_build_value(const char *, va_list, int);
|
|
|
|
|
1997-11-19 14:53:33 -04:00
|
|
|
/* Package context -- the full module name for package imports */
|
|
|
|
char *_Py_PackageContext = NULL;
|
|
|
|
|
1997-08-02 00:07:46 -03:00
|
|
|
/* Py_InitModule4() parameters:
|
1995-01-09 13:47:20 -04:00
|
|
|
- name is the module name
|
|
|
|
- methods is the list of top-level functions
|
|
|
|
- doc is the documentation string
|
|
|
|
- passthrough is passed as self to functions defined in the module
|
|
|
|
- api_version is the value of PYTHON_API_VERSION at the time the
|
|
|
|
module was compiled
|
1997-08-02 00:07:46 -03:00
|
|
|
|
|
|
|
Return value is a borrowed reference to the module object; or NULL
|
|
|
|
if an error occurred (in Python 1.4 and before, errors were fatal).
|
|
|
|
Errors may still leak memory.
|
1995-01-07 08:43:18 -04:00
|
|
|
*/
|
1994-08-30 05:27:36 -03:00
|
|
|
|
1995-01-09 13:47:20 -04:00
|
|
|
static char api_version_warning[] =
|
2001-07-31 10:24:44 -03:00
|
|
|
"Python C API version mismatch for module %.100s:\
|
|
|
|
This Python has API version %d, module %.100s has version %d.";
|
1995-01-09 13:47:20 -04:00
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
2005-12-10 14:50:16 -04:00
|
|
|
Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *passthrough, int module_api_version)
|
1990-10-14 09:07:46 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *m, *d, *v, *n;
|
|
|
|
PyMethodDef *ml;
|
2010-12-14 21:36:03 -04:00
|
|
|
PyInterpreterState *interp = PyThreadState_Get()->interp;
|
|
|
|
if (interp->modules == NULL)
|
|
|
|
Py_FatalError("Python import machinery not initialized");
|
2010-05-09 11:46:46 -03:00
|
|
|
if (module_api_version != PYTHON_API_VERSION) {
|
|
|
|
char message[512];
|
|
|
|
PyOS_snprintf(message, sizeof(message),
|
|
|
|
api_version_warning, name,
|
|
|
|
PYTHON_API_VERSION, name,
|
|
|
|
module_api_version);
|
|
|
|
if (PyErr_Warn(PyExc_RuntimeWarning, message))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* Make sure name is fully qualified.
|
|
|
|
|
|
|
|
This is a bit of a hack: when the shared library is loaded,
|
|
|
|
the module name is "package.module", but the module calls
|
|
|
|
Py_InitModule*() with just "module" for the name. The shared
|
|
|
|
library loader squirrels away the true name of the module in
|
|
|
|
_Py_PackageContext, and Py_InitModule*() will substitute this
|
|
|
|
(if the name actually matches).
|
|
|
|
*/
|
|
|
|
if (_Py_PackageContext != NULL) {
|
|
|
|
char *p = strrchr(_Py_PackageContext, '.');
|
|
|
|
if (p != NULL && strcmp(name, p+1) == 0) {
|
|
|
|
name = _Py_PackageContext;
|
|
|
|
_Py_PackageContext = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((m = PyImport_AddModule(name)) == NULL)
|
|
|
|
return NULL;
|
|
|
|
d = PyModule_GetDict(m);
|
|
|
|
if (methods != NULL) {
|
|
|
|
n = PyString_FromString(name);
|
|
|
|
if (n == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (ml = methods; ml->ml_name != NULL; ml++) {
|
|
|
|
if ((ml->ml_flags & METH_CLASS) ||
|
|
|
|
(ml->ml_flags & METH_STATIC)) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"module functions cannot set"
|
|
|
|
" METH_CLASS or METH_STATIC");
|
|
|
|
Py_DECREF(n);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
v = PyCFunction_NewEx(ml, passthrough, n);
|
|
|
|
if (v == NULL) {
|
|
|
|
Py_DECREF(n);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
Py_DECREF(n);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_DECREF(v);
|
|
|
|
}
|
|
|
|
Py_DECREF(n);
|
|
|
|
}
|
|
|
|
if (doc != NULL) {
|
|
|
|
v = PyString_FromString(doc);
|
|
|
|
if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
|
|
|
|
Py_XDECREF(v);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
Py_DECREF(v);
|
|
|
|
}
|
|
|
|
return m;
|
1990-10-14 09:07:46 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1993-02-08 11:49:17 -04:00
|
|
|
/* Helper for mkvalue() to scan the length of a format */
|
1992-04-13 12:53:41 -03:00
|
|
|
|
2003-01-30 11:08:25 -04:00
|
|
|
static int
|
2005-12-10 14:50:16 -04:00
|
|
|
countformat(const char *format, int endchar)
|
1992-04-13 12:53:41 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
int count = 0;
|
|
|
|
int level = 0;
|
|
|
|
while (level > 0 || *format != endchar) {
|
|
|
|
switch (*format) {
|
|
|
|
case '\0':
|
|
|
|
/* Premature end */
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"unmatched paren in format");
|
|
|
|
return -1;
|
|
|
|
case '(':
|
|
|
|
case '[':
|
|
|
|
case '{':
|
|
|
|
if (level == 0)
|
|
|
|
count++;
|
|
|
|
level++;
|
|
|
|
break;
|
|
|
|
case ')':
|
|
|
|
case ']':
|
|
|
|
case '}':
|
|
|
|
level--;
|
|
|
|
break;
|
|
|
|
case '#':
|
|
|
|
case '&':
|
|
|
|
case ',':
|
|
|
|
case ':':
|
|
|
|
case ' ':
|
|
|
|
case '\t':
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (level == 0)
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
format++;
|
|
|
|
}
|
|
|
|
return count;
|
1992-04-13 12:53:41 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Generic function to create a value -- the inverse of getargs() */
|
|
|
|
/* After an original idea and first implementation by Steven Miale */
|
|
|
|
|
2006-04-14 06:08:42 -03:00
|
|
|
static PyObject *do_mktuple(const char**, va_list *, int, int, int);
|
|
|
|
static PyObject *do_mklist(const char**, va_list *, int, int, int);
|
|
|
|
static PyObject *do_mkdict(const char**, va_list *, int, int, int);
|
|
|
|
static PyObject *do_mkvalue(const char**, va_list *, int);
|
1992-04-13 12:53:41 -03:00
|
|
|
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2016-05-20 16:31:24 -03:00
|
|
|
static void
|
|
|
|
do_ignore(const char **p_format, va_list *p_va, int endchar, int n, int flags)
|
|
|
|
{
|
|
|
|
PyObject *v;
|
|
|
|
int i;
|
|
|
|
assert(PyErr_Occurred());
|
|
|
|
v = PyTuple_New(n);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
PyObject *exception, *value, *tb, *w;
|
|
|
|
PyErr_Fetch(&exception, &value, &tb);
|
|
|
|
w = do_mkvalue(p_format, p_va, flags);
|
|
|
|
PyErr_Restore(exception, value, tb);
|
|
|
|
if (w != NULL) {
|
|
|
|
if (v != NULL) {
|
|
|
|
PyTuple_SET_ITEM(v, i, w);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Py_DECREF(w);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Py_XDECREF(v);
|
|
|
|
if (**p_format != endchar) {
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"Unmatched paren in format");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (endchar)
|
|
|
|
++*p_format;
|
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
2006-04-14 06:08:42 -03:00
|
|
|
do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
|
1995-01-02 15:04:15 -04:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *d;
|
|
|
|
int i;
|
|
|
|
if (n < 0)
|
|
|
|
return NULL;
|
2016-05-20 16:31:24 -03:00
|
|
|
if (n % 2) {
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"Bad dict format");
|
|
|
|
do_ignore(p_format, p_va, endchar, n, flags);
|
2010-05-09 11:46:46 -03:00
|
|
|
return NULL;
|
2016-05-20 16:31:24 -03:00
|
|
|
}
|
2010-05-09 11:46:46 -03:00
|
|
|
/* Note that we can't bail immediately on error as this will leak
|
|
|
|
refcounts on any 'N' arguments. */
|
2016-05-20 16:31:24 -03:00
|
|
|
if ((d = PyDict_New()) == NULL) {
|
|
|
|
do_ignore(p_format, p_va, endchar, n, flags);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-09 11:46:46 -03:00
|
|
|
for (i = 0; i < n; i+= 2) {
|
|
|
|
PyObject *k, *v;
|
2016-05-20 16:31:24 -03:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
k = do_mkvalue(p_format, p_va, flags);
|
|
|
|
if (k == NULL) {
|
2016-05-20 16:31:24 -03:00
|
|
|
do_ignore(p_format, p_va, endchar, n - i - 1, flags);
|
|
|
|
Py_DECREF(d);
|
|
|
|
return NULL;
|
2010-05-09 11:46:46 -03:00
|
|
|
}
|
|
|
|
v = do_mkvalue(p_format, p_va, flags);
|
2016-05-20 16:31:24 -03:00
|
|
|
if (v == NULL || PyDict_SetItem(d, k, v) < 0) {
|
|
|
|
do_ignore(p_format, p_va, endchar, n - i - 2, flags);
|
|
|
|
Py_DECREF(k);
|
|
|
|
Py_XDECREF(v);
|
2010-05-09 11:46:46 -03:00
|
|
|
Py_DECREF(d);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-05-20 16:31:24 -03:00
|
|
|
Py_DECREF(k);
|
|
|
|
Py_DECREF(v);
|
2010-05-09 11:46:46 -03:00
|
|
|
}
|
2016-05-20 16:31:24 -03:00
|
|
|
if (**p_format != endchar) {
|
2010-05-09 11:46:46 -03:00
|
|
|
Py_DECREF(d);
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"Unmatched paren in format");
|
2016-05-20 16:31:24 -03:00
|
|
|
return NULL;
|
2010-05-09 11:46:46 -03:00
|
|
|
}
|
2016-05-20 16:31:24 -03:00
|
|
|
if (endchar)
|
2010-05-09 11:46:46 -03:00
|
|
|
++*p_format;
|
|
|
|
return d;
|
1995-01-02 15:04:15 -04:00
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
2006-04-14 06:08:42 -03:00
|
|
|
do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
|
1995-01-02 15:04:15 -04:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *v;
|
|
|
|
int i;
|
|
|
|
if (n < 0)
|
|
|
|
return NULL;
|
|
|
|
/* Note that we can't bail immediately on error as this will leak
|
|
|
|
refcounts on any 'N' arguments. */
|
2016-05-20 16:31:24 -03:00
|
|
|
v = PyList_New(n);
|
|
|
|
if (v == NULL) {
|
|
|
|
do_ignore(p_format, p_va, endchar, n, flags);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-09 11:46:46 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
PyObject *w = do_mkvalue(p_format, p_va, flags);
|
|
|
|
if (w == NULL) {
|
2016-05-20 16:31:24 -03:00
|
|
|
do_ignore(p_format, p_va, endchar, n - i - 1, flags);
|
|
|
|
Py_DECREF(v);
|
|
|
|
return NULL;
|
2010-05-09 11:46:46 -03:00
|
|
|
}
|
|
|
|
PyList_SET_ITEM(v, i, w);
|
|
|
|
}
|
|
|
|
if (**p_format != endchar) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"Unmatched paren in format");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (endchar)
|
|
|
|
++*p_format;
|
|
|
|
return v;
|
1995-01-02 15:04:15 -04:00
|
|
|
}
|
|
|
|
|
2001-08-17 15:39:25 -03:00
|
|
|
#ifdef Py_USING_UNICODE
|
2000-04-28 11:42:37 -03:00
|
|
|
static int
|
|
|
|
_ustrlen(Py_UNICODE *u)
|
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
int i = 0;
|
|
|
|
Py_UNICODE *v = u;
|
|
|
|
while (*v != 0) { i++; v++; }
|
|
|
|
return i;
|
2000-04-28 11:42:37 -03:00
|
|
|
}
|
2001-08-17 15:39:25 -03:00
|
|
|
#endif
|
2000-04-28 11:42:37 -03:00
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
2006-04-14 06:08:42 -03:00
|
|
|
do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
|
1992-04-13 12:53:41 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *v;
|
|
|
|
int i;
|
|
|
|
if (n < 0)
|
|
|
|
return NULL;
|
|
|
|
/* Note that we can't bail immediately on error as this will leak
|
|
|
|
refcounts on any 'N' arguments. */
|
2016-05-20 16:31:24 -03:00
|
|
|
if ((v = PyTuple_New(n)) == NULL) {
|
|
|
|
do_ignore(p_format, p_va, endchar, n, flags);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-09 11:46:46 -03:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
PyObject *w = do_mkvalue(p_format, p_va, flags);
|
|
|
|
if (w == NULL) {
|
2016-05-20 16:31:24 -03:00
|
|
|
do_ignore(p_format, p_va, endchar, n - i - 1, flags);
|
|
|
|
Py_DECREF(v);
|
|
|
|
return NULL;
|
2010-05-09 11:46:46 -03:00
|
|
|
}
|
|
|
|
PyTuple_SET_ITEM(v, i, w);
|
|
|
|
}
|
|
|
|
if (**p_format != endchar) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"Unmatched paren in format");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (endchar)
|
|
|
|
++*p_format;
|
|
|
|
return v;
|
1992-04-13 12:53:41 -03:00
|
|
|
}
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
static PyObject *
|
2006-04-14 06:08:42 -03:00
|
|
|
do_mkvalue(const char **p_format, va_list *p_va, int flags)
|
1992-05-15 08:04:59 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
for (;;) {
|
|
|
|
switch (*(*p_format)++) {
|
|
|
|
case '(':
|
|
|
|
return do_mktuple(p_format, p_va, ')',
|
|
|
|
countformat(*p_format, ')'), flags);
|
|
|
|
|
|
|
|
case '[':
|
|
|
|
return do_mklist(p_format, p_va, ']',
|
|
|
|
countformat(*p_format, ']'), flags);
|
|
|
|
|
|
|
|
case '{':
|
|
|
|
return do_mkdict(p_format, p_va, '}',
|
|
|
|
countformat(*p_format, '}'), flags);
|
|
|
|
|
|
|
|
case 'b':
|
|
|
|
case 'B':
|
|
|
|
case 'h':
|
|
|
|
case 'i':
|
|
|
|
return PyInt_FromLong((long)va_arg(*p_va, int));
|
|
|
|
|
|
|
|
case 'H':
|
|
|
|
return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
|
|
|
|
|
|
|
|
case 'I':
|
|
|
|
{
|
|
|
|
unsigned int n;
|
|
|
|
n = va_arg(*p_va, unsigned int);
|
|
|
|
if (n > (unsigned long)PyInt_GetMax())
|
|
|
|
return PyLong_FromUnsignedLong((unsigned long)n);
|
|
|
|
else
|
|
|
|
return PyInt_FromLong(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
case 'n':
|
2006-02-15 13:27:45 -04:00
|
|
|
#if SIZEOF_SIZE_T!=SIZEOF_LONG
|
2010-05-09 11:46:46 -03:00
|
|
|
return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
|
2006-02-15 13:27:45 -04:00
|
|
|
#endif
|
2010-05-09 11:46:46 -03:00
|
|
|
/* Fall through from 'n' to 'l' if Py_ssize_t is long */
|
|
|
|
case 'l':
|
|
|
|
return PyInt_FromLong(va_arg(*p_va, long));
|
|
|
|
|
|
|
|
case 'k':
|
|
|
|
{
|
|
|
|
unsigned long n;
|
|
|
|
n = va_arg(*p_va, unsigned long);
|
|
|
|
if (n > (unsigned long)PyInt_GetMax())
|
|
|
|
return PyLong_FromUnsignedLong(n);
|
|
|
|
else
|
|
|
|
return PyInt_FromLong(n);
|
|
|
|
}
|
2003-04-17 19:01:10 -03:00
|
|
|
|
1999-01-25 17:48:56 -04:00
|
|
|
#ifdef HAVE_LONG_LONG
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'L':
|
|
|
|
return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
|
2003-04-17 19:01:10 -03:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'K':
|
|
|
|
return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
|
1998-08-04 19:46:29 -03:00
|
|
|
#endif
|
2001-08-17 15:39:25 -03:00
|
|
|
#ifdef Py_USING_UNICODE
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'u':
|
|
|
|
{
|
|
|
|
PyObject *v;
|
|
|
|
Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
|
|
|
|
Py_ssize_t n;
|
|
|
|
if (**p_format == '#') {
|
|
|
|
++*p_format;
|
|
|
|
if (flags & FLAG_SIZE_T)
|
|
|
|
n = va_arg(*p_va, Py_ssize_t);
|
|
|
|
else
|
|
|
|
n = va_arg(*p_va, int);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n = -1;
|
|
|
|
if (u == NULL) {
|
|
|
|
v = Py_None;
|
|
|
|
Py_INCREF(v);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (n < 0)
|
|
|
|
n = _ustrlen(u);
|
|
|
|
v = PyUnicode_FromUnicode(u, n);
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
2001-08-17 15:39:25 -03:00
|
|
|
#endif
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'f':
|
|
|
|
case 'd':
|
|
|
|
return PyFloat_FromDouble(
|
|
|
|
(double)va_arg(*p_va, va_double));
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2001-03-12 17:03:26 -04:00
|
|
|
#ifndef WITHOUT_COMPLEX
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'D':
|
|
|
|
return PyComplex_FromCComplex(
|
|
|
|
*((Py_complex *)va_arg(*p_va, Py_complex *)));
|
2001-03-12 17:03:26 -04:00
|
|
|
#endif /* WITHOUT_COMPLEX */
|
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
case 'c':
|
|
|
|
{
|
|
|
|
char p[1];
|
|
|
|
p[0] = (char)va_arg(*p_va, int);
|
|
|
|
return PyString_FromStringAndSize(p, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
case 's':
|
|
|
|
case 'z':
|
|
|
|
{
|
|
|
|
PyObject *v;
|
|
|
|
char *str = va_arg(*p_va, char *);
|
|
|
|
Py_ssize_t n;
|
|
|
|
if (**p_format == '#') {
|
|
|
|
++*p_format;
|
|
|
|
if (flags & FLAG_SIZE_T)
|
|
|
|
n = va_arg(*p_va, Py_ssize_t);
|
|
|
|
else
|
|
|
|
n = va_arg(*p_va, int);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n = -1;
|
|
|
|
if (str == NULL) {
|
|
|
|
v = Py_None;
|
|
|
|
Py_INCREF(v);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (n < 0) {
|
|
|
|
size_t m = strlen(str);
|
|
|
|
if (m > PY_SSIZE_T_MAX) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"string too long for Python string");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
n = (Py_ssize_t)m;
|
|
|
|
}
|
|
|
|
v = PyString_FromStringAndSize(str, n);
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 'N':
|
|
|
|
case 'S':
|
|
|
|
case 'O':
|
|
|
|
if (**p_format == '&') {
|
|
|
|
typedef PyObject *(*converter)(void *);
|
|
|
|
converter func = va_arg(*p_va, converter);
|
|
|
|
void *arg = va_arg(*p_va, void *);
|
|
|
|
++*p_format;
|
|
|
|
return (*func)(arg);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PyObject *v;
|
|
|
|
v = va_arg(*p_va, PyObject *);
|
|
|
|
if (v != NULL) {
|
|
|
|
if (*(*p_format - 1) != 'N')
|
|
|
|
Py_INCREF(v);
|
|
|
|
}
|
|
|
|
else if (!PyErr_Occurred())
|
|
|
|
/* If a NULL was passed
|
|
|
|
* because a call that should
|
|
|
|
* have constructed a value
|
|
|
|
* failed, that's OK, and we
|
|
|
|
* pass the error on; but if
|
|
|
|
* no error occurred it's not
|
|
|
|
* clear that the caller knew
|
|
|
|
* what she was doing. */
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"NULL object passed to Py_BuildValue");
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
case ':':
|
|
|
|
case ',':
|
|
|
|
case ' ':
|
|
|
|
case '\t':
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
PyErr_SetString(PyExc_SystemError,
|
|
|
|
"bad format char passed to Py_BuildValue");
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
1992-04-13 07:48:55 -03:00
|
|
|
}
|
|
|
|
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2003-01-30 11:08:25 -04:00
|
|
|
PyObject *
|
2005-12-10 14:50:16 -04:00
|
|
|
Py_BuildValue(const char *format, ...)
|
1992-04-13 07:48:55 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
va_list va;
|
|
|
|
PyObject* retval;
|
|
|
|
va_start(va, format);
|
|
|
|
retval = va_build_value(format, va, 0);
|
|
|
|
va_end(va);
|
|
|
|
return retval;
|
2006-04-14 06:08:42 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
_Py_BuildValue_SizeT(const char *format, ...)
|
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
va_list va;
|
|
|
|
PyObject* retval;
|
|
|
|
va_start(va, format);
|
|
|
|
retval = va_build_value(format, va, FLAG_SIZE_T);
|
|
|
|
va_end(va);
|
|
|
|
return retval;
|
1992-04-13 07:48:55 -03:00
|
|
|
}
|
1993-03-16 08:15:04 -04:00
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
2005-12-10 14:50:16 -04:00
|
|
|
Py_VaBuildValue(const char *format, va_list va)
|
2006-04-14 06:08:42 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
return va_build_value(format, va, 0);
|
2006-04-14 06:08:42 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
_Py_VaBuildValue_SizeT(const char *format, va_list va)
|
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
return va_build_value(format, va, FLAG_SIZE_T);
|
2006-04-14 06:08:42 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
va_build_value(const char *format, va_list va, int flags)
|
1993-03-16 08:15:04 -04:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
const char *f = format;
|
|
|
|
int n = countformat(f, '\0');
|
|
|
|
va_list lva;
|
1995-01-02 15:04:15 -04:00
|
|
|
|
|
|
|
#ifdef VA_LIST_IS_ARRAY
|
2010-05-09 11:46:46 -03:00
|
|
|
memcpy(lva, va, sizeof(va_list));
|
2002-07-28 07:23:27 -03:00
|
|
|
#else
|
|
|
|
#ifdef __va_copy
|
2010-05-09 11:46:46 -03:00
|
|
|
__va_copy(lva, va);
|
1995-01-02 15:04:15 -04:00
|
|
|
#else
|
2010-05-09 11:46:46 -03:00
|
|
|
lva = va;
|
2002-07-28 07:23:27 -03:00
|
|
|
#endif
|
1995-01-02 15:04:15 -04:00
|
|
|
#endif
|
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
if (n < 0)
|
|
|
|
return NULL;
|
|
|
|
if (n == 0) {
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
return Py_None;
|
|
|
|
}
|
|
|
|
if (n == 1)
|
|
|
|
return do_mkvalue(&f, &lva, flags);
|
|
|
|
return do_mktuple(&f, &lva, '\0', n, flags);
|
1995-01-02 15:04:15 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
2005-12-10 14:50:16 -04:00
|
|
|
PyEval_CallFunction(PyObject *obj, const char *format, ...)
|
1995-01-02 15:04:15 -04:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
va_list vargs;
|
|
|
|
PyObject *args;
|
|
|
|
PyObject *res;
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
va_start(vargs, format);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
args = Py_VaBuildValue(format, vargs);
|
|
|
|
va_end(vargs);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
if (args == NULL)
|
|
|
|
return NULL;
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
res = PyEval_CallObject(obj, args);
|
|
|
|
Py_DECREF(args);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
return res;
|
1995-01-02 15:04:15 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-04-29 17:08:16 -03:00
|
|
|
PyObject *
|
2005-12-10 14:50:16 -04:00
|
|
|
PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
|
1995-01-02 15:04:15 -04:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
va_list vargs;
|
|
|
|
PyObject *meth;
|
|
|
|
PyObject *args;
|
|
|
|
PyObject *res;
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
meth = PyObject_GetAttrString(obj, methodname);
|
|
|
|
if (meth == NULL)
|
|
|
|
return NULL;
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
va_start(vargs, format);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
args = Py_VaBuildValue(format, vargs);
|
|
|
|
va_end(vargs);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
if (args == NULL) {
|
|
|
|
Py_DECREF(meth);
|
|
|
|
return NULL;
|
|
|
|
}
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
res = PyEval_CallObject(meth, args);
|
|
|
|
Py_DECREF(meth);
|
|
|
|
Py_DECREF(args);
|
1995-01-02 15:04:15 -04:00
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
return res;
|
1993-03-16 08:15:04 -04:00
|
|
|
}
|
2000-09-23 00:24:27 -03:00
|
|
|
|
|
|
|
int
|
2005-12-10 14:50:16 -04:00
|
|
|
PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
|
2000-09-23 00:24:27 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *dict;
|
|
|
|
if (!PyModule_Check(m)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"PyModule_AddObject() needs module as first arg");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!o) {
|
|
|
|
if (!PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"PyModule_AddObject() needs non-NULL value");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
dict = PyModule_GetDict(m);
|
|
|
|
if (dict == NULL) {
|
|
|
|
/* Internal error -- modules must have a dict! */
|
|
|
|
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
|
|
|
|
PyModule_GetName(m));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (PyDict_SetItemString(dict, name, o))
|
|
|
|
return -1;
|
|
|
|
Py_DECREF(o);
|
|
|
|
return 0;
|
2000-09-23 00:24:27 -03:00
|
|
|
}
|
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
int
|
2005-12-10 14:50:16 -04:00
|
|
|
PyModule_AddIntConstant(PyObject *m, const char *name, long value)
|
2000-09-23 00:24:27 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *o = PyInt_FromLong(value);
|
|
|
|
if (!o)
|
|
|
|
return -1;
|
|
|
|
if (PyModule_AddObject(m, name, o) == 0)
|
|
|
|
return 0;
|
|
|
|
Py_DECREF(o);
|
|
|
|
return -1;
|
2000-09-23 00:24:27 -03:00
|
|
|
}
|
|
|
|
|
2010-05-09 11:46:46 -03:00
|
|
|
int
|
2005-12-10 14:50:16 -04:00
|
|
|
PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
|
2000-09-23 00:24:27 -03:00
|
|
|
{
|
2010-05-09 11:46:46 -03:00
|
|
|
PyObject *o = PyString_FromString(value);
|
|
|
|
if (!o)
|
|
|
|
return -1;
|
|
|
|
if (PyModule_AddObject(m, name, o) == 0)
|
|
|
|
return 0;
|
|
|
|
Py_DECREF(o);
|
|
|
|
return -1;
|
2000-09-23 00:24:27 -03:00
|
|
|
}
|