cpython/Python/modsupport.c

503 lines
10 KiB
C
Raw Normal View History

1991-02-19 08:39:46 -04:00
/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
1991-02-19 08:39:46 -04:00
All Rights Reserved
1996-10-25 11:44:06 -03:00
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
1991-02-19 08:39:46 -04:00
provided that the above copyright notice appear in all copies and that
1996-10-25 11:44:06 -03:00
both that copyright notice and this permission notice appear in
1991-02-19 08:39:46 -04:00
supporting documentation, and that the names of Stichting Mathematisch
1996-10-25 11:44:06 -03:00
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
1991-02-19 08:39:46 -04:00
******************************************************************/
1990-10-14 09:07:46 -03:00
/* Module support implementation */
#include "Python.h"
1990-10-14 09:07:46 -03:00
1994-08-30 05:27:36 -03:00
#ifdef MPW /* MPW pushes 'extended' for float and double types with varargs */
typedef extended va_double;
#else
1994-08-30 05:27:36 -03:00
typedef double va_double;
#endif
/* Package context -- the full module name for package imports */
char *_Py_PackageContext = NULL;
/* 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
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.
*/
1994-08-30 05:27:36 -03:00
1995-01-09 13:47:20 -04:00
static char api_version_warning[] =
"WARNING: Python C API version mismatch for module %s:\n\
This Python has API version %d, module %s has version %d.\n";
1995-01-09 13:47:20 -04:00
PyObject *
Py_InitModule4(name, methods, doc, passthrough, module_api_version)
1990-10-14 09:07:46 -03:00
char *name;
PyMethodDef *methods;
char *doc;
PyObject *passthrough;
1995-01-09 13:47:20 -04:00
int module_api_version;
1990-10-14 09:07:46 -03:00
{
PyObject *m, *d, *v;
PyMethodDef *ml;
1995-01-09 13:47:20 -04:00
if (module_api_version != PYTHON_API_VERSION)
fprintf(stderr, api_version_warning,
name, PYTHON_API_VERSION, name, module_api_version);
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);
1990-10-14 09:07:46 -03:00
for (ml = methods; ml->ml_name != NULL; ml++) {
v = PyCFunction_New(ml, passthrough);
if (v == NULL)
return NULL;
if (PyDict_SetItemString(d, ml->ml_name, v) != 0)
return NULL;
Py_DECREF(v);
1990-10-14 09:07:46 -03:00
}
if (doc != NULL) {
v = PyString_FromString(doc);
if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0)
return NULL;
Py_DECREF(v);
}
1990-12-20 11:06:42 -04:00
return m;
1990-10-14 09:07:46 -03:00
}
/* Helper for mkvalue() to scan the length of a format */
1992-04-13 12:53:41 -03:00
static int countformat Py_PROTO((char *format, int endchar));
1992-04-13 12:53:41 -03:00
static int countformat(format, endchar)
char *format;
int endchar;
{
int count = 0;
int level = 0;
while (level > 0 || *format != endchar) {
switch (*format) {
case '\0':
1992-04-13 12:53:41 -03:00
/* Premature end */
PyErr_SetString(PyExc_SystemError,
"unmatched paren in format");
1992-04-13 12:53:41 -03:00
return -1;
case '(':
case '[':
case '{':
1992-04-13 12:53:41 -03:00
if (level == 0)
count++;
level++;
break;
case ')':
case ']':
case '}':
1992-04-13 12:53:41 -03:00
level--;
break;
case '#':
case '&':
case ',':
case ':':
case ' ':
case '\t':
break;
default:
if (level == 0)
count++;
}
1992-04-13 12:53:41 -03:00
format++;
}
return count;
}
/* Generic function to create a value -- the inverse of getargs() */
/* After an original idea and first implementation by Steven Miale */
static PyObject *do_mktuple Py_PROTO((char**, va_list *, int, int));
static PyObject *do_mklist Py_PROTO((char**, va_list *, int, int));
static PyObject *do_mkdict Py_PROTO((char**, va_list *, int, int));
static PyObject *do_mkvalue Py_PROTO((char**, va_list *));
1992-04-13 12:53:41 -03:00
static PyObject *
do_mkdict(p_format, p_va, endchar, n)
char **p_format;
va_list *p_va;
int endchar;
int n;
{
PyObject *d;
int i;
if (n < 0)
return NULL;
if ((d = PyDict_New()) == NULL)
return NULL;
for (i = 0; i < n; i+= 2) {
PyObject *k, *v;
int err;
k = do_mkvalue(p_format, p_va);
if (k == NULL) {
Py_DECREF(d);
return NULL;
}
v = do_mkvalue(p_format, p_va);
if (v == NULL) {
Py_DECREF(k);
Py_DECREF(d);
return NULL;
}
err = PyDict_SetItem(d, k, v);
Py_DECREF(k);
Py_DECREF(v);
if (err < 0) {
Py_DECREF(d);
return NULL;
}
}
if (d != NULL && **p_format != endchar) {
Py_DECREF(d);
d = NULL;
PyErr_SetString(PyExc_SystemError,
"Unmatched paren in format");
}
else if (endchar)
++*p_format;
return d;
}
static PyObject *
do_mklist(p_format, p_va, endchar, n)
char **p_format;
va_list *p_va;
int endchar;
int n;
{
PyObject *v;
int i;
if (n < 0)
return NULL;
if ((v = PyList_New(n)) == NULL)
return NULL;
for (i = 0; i < n; i++) {
PyObject *w = do_mkvalue(p_format, p_va);
if (w == NULL) {
Py_DECREF(v);
return NULL;
}
PyList_SetItem(v, i, w);
}
if (v != NULL && **p_format != endchar) {
Py_DECREF(v);
v = NULL;
PyErr_SetString(PyExc_SystemError,
"Unmatched paren in format");
}
else if (endchar)
++*p_format;
return v;
}
static PyObject *
1992-04-13 12:53:41 -03:00
do_mktuple(p_format, p_va, endchar, n)
char **p_format;
va_list *p_va;
int endchar;
int n;
{
PyObject *v;
1992-04-13 12:53:41 -03:00
int i;
if (n < 0)
return NULL;
if ((v = PyTuple_New(n)) == NULL)
1992-04-13 12:53:41 -03:00
return NULL;
for (i = 0; i < n; i++) {
PyObject *w = do_mkvalue(p_format, p_va);
1992-04-13 12:53:41 -03:00
if (w == NULL) {
Py_DECREF(v);
1992-04-13 12:53:41 -03:00
return NULL;
}
PyTuple_SetItem(v, i, w);
1992-04-13 12:53:41 -03:00
}
if (v != NULL && **p_format != endchar) {
Py_DECREF(v);
1992-04-13 12:53:41 -03:00
v = NULL;
PyErr_SetString(PyExc_SystemError,
"Unmatched paren in format");
1992-04-13 12:53:41 -03:00
}
else if (endchar)
++*p_format;
return v;
}
static PyObject *
do_mkvalue(p_format, p_va)
char **p_format;
va_list *p_va;
{
for (;;) {
switch (*(*p_format)++) {
case '(':
return do_mktuple(p_format, p_va, ')',
countformat(*p_format, ')'));
case '[':
return do_mklist(p_format, p_va, ']',
countformat(*p_format, ']'));
case '{':
return do_mkdict(p_format, p_va, '}',
countformat(*p_format, '}'));
case 'b':
case 'h':
case 'i':
return PyInt_FromLong((long)va_arg(*p_va, int));
case 'l':
return PyInt_FromLong((long)va_arg(*p_va, long));
#if HAVE_LONG_LONG
case 'L':
return PyLong_FromLongLong((long long)va_arg(*p_va, long long));
#endif
case 'f':
case 'd':
return PyFloat_FromDouble(
(double)va_arg(*p_va, va_double));
case 'c':
1992-04-13 12:53:41 -03:00
{
char p[1];
p[0] = va_arg(*p_va, int);
return PyString_FromStringAndSize(p, 1);
1992-04-13 12:53:41 -03:00
}
case 's':
case 'z':
1992-04-13 07:48:55 -03:00
{
PyObject *v;
1992-04-13 07:48:55 -03:00
char *str = va_arg(*p_va, char *);
int n;
if (**p_format == '#') {
++*p_format;
n = va_arg(*p_va, int);
}
else
n = -1;
if (str == NULL) {
v = Py_None;
Py_INCREF(v);
1992-04-13 07:48:55 -03:00
}
else {
if (n < 0)
n = strlen(str);
v = PyString_FromStringAndSize(str, n);
1992-04-13 07:48:55 -03:00
}
1992-04-13 12:53:41 -03:00
return v;
1992-04-13 07:48:55 -03:00
}
case 'S':
case 'O':
if (**p_format == '&') {
typedef PyObject *(*converter) Py_PROTO((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 *);
1992-04-13 12:53:41 -03:00
if (v != NULL)
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");
1992-04-13 12:53:41 -03:00
return v;
1992-04-13 07:48:55 -03:00
}
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
}
}
1994-08-30 05:27:36 -03:00
#ifdef HAVE_STDARG_PROTOTYPES
1992-04-13 12:53:41 -03:00
/* VARARGS 2 */
PyObject *Py_BuildValue(char *format, ...)
1992-04-13 12:53:41 -03:00
#else
/* VARARGS */
PyObject *Py_BuildValue(va_alist) va_dcl
1992-04-13 12:53:41 -03:00
#endif
1992-04-13 07:48:55 -03:00
{
1992-04-13 12:53:41 -03:00
va_list va;
PyObject* retval;
1994-08-30 05:27:36 -03:00
#ifdef HAVE_STDARG_PROTOTYPES
1992-04-13 12:53:41 -03:00
va_start(va, format);
#else
char *format;
va_start(va);
format = va_arg(va, char *);
#endif
retval = Py_VaBuildValue(format, va);
1992-04-13 12:53:41 -03:00
va_end(va);
return retval;
1992-04-13 07:48:55 -03:00
}
PyObject *
Py_VaBuildValue(format, va)
char *format;
va_list va;
{
char *f = format;
int n = countformat(f, '\0');
va_list lva;
#ifdef VA_LIST_IS_ARRAY
memcpy(lva, va, sizeof(va_list));
#else
lva = va;
#endif
if (n < 0)
return NULL;
if (n == 0) {
Py_INCREF(Py_None);
return Py_None;
}
if (n == 1)
return do_mkvalue(&f, &lva);
return do_mktuple(&f, &lva, '\0', n);
}
#ifdef HAVE_STDARG_PROTOTYPES
PyObject *
PyEval_CallFunction(PyObject *obj, char *format, ...)
#else
PyObject *
PyEval_CallFunction(obj, format, va_alist)
PyObject *obj;
char *format;
va_dcl
#endif
{
va_list vargs;
PyObject *args;
PyObject *res;
#ifdef HAVE_STDARG_PROTOTYPES
va_start(vargs, format);
#else
va_start(vargs);
#endif
args = Py_VaBuildValue(format, vargs);
va_end(vargs);
if (args == NULL)
return NULL;
res = PyEval_CallObject(obj, args);
Py_DECREF(args);
return res;
}
#ifdef HAVE_STDARG_PROTOTYPES
PyObject *
PyEval_CallMethod(PyObject *obj, char *methonname, char *format, ...)
#else
PyObject *
PyEval_CallMethod(obj, methonname, format, va_alist)
PyObject *obj;
char *methonname;
char *format;
va_dcl
#endif
{
va_list vargs;
PyObject *meth;
PyObject *args;
PyObject *res;
meth = PyObject_GetAttrString(obj, methonname);
if (meth == NULL)
return NULL;
#ifdef HAVE_STDARG_PROTOTYPES
va_start(vargs, format);
#else
va_start(vargs);
#endif
args = Py_VaBuildValue(format, vargs);
va_end(vargs);
if (args == NULL) {
Py_DECREF(meth);
return NULL;
}
res = PyEval_CallObject(meth, args);
Py_DECREF(meth);
Py_DECREF(args);
return res;
}