An initial stab at calling random C routines from Python

Mac/Modules/calldll.c

+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+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.
+
+******************************************************************/
+
+#include "Python.h"
+#include "macglue.h"
+#include "macdefs.h"
+
+extern PyObject *ResObj_New Py_PROTO((Handle));
+extern int ResObj_Convert Py_PROTO((PyObject *, Handle *));
+
+#include <CodeFragments.h>
+
+static PyObject *ErrorObject;
+
+#define PARANOID(arg) \
+	if ( arg == 0 ) {PyErr_SetString(ErrorObject, "Internal error: NULL arg!"); return 0; }
+	
+/* Prototype we use for routines */
+
+typedef long anything;
+typedef anything (*anyroutine) Py_PROTO((...));
+
+#define MAXNAME 31	/* Maximum size of names, for printing only */
+#define MAXARG 8	/* Maximum number of arguments */
+
+/*
+** Routines to convert arguments between Python and C
+*/
+typedef anything (*py2c_converter) Py_PROTO((PyObject *));
+typedef PyObject *(*c2py_converter) Py_PROTO((anything));
+
+/* Dummy routine for arguments that are output-only */
+static anything
+py2c_dummy(arg)
+	PyObject  *arg;
+{
+	return 0;
+}
+
+/* Routine to allocate storage for output integers */
+static anything
+py2c_alloc(arg)
+	PyObject *arg;
+{
+	char *ptr;
+	
+	if( (ptr=malloc(sizeof(anything))) == 0 )
+		PyErr_NoMemory();
+	return (anything)ptr;
+}
+
+/* Dummy routine for arguments that are input-only */
+static PyObject *
+c2py_dummy(arg)
+	anything arg;
+{
+	return 0;
+}
+
+/* Routine to de-allocate storage for input-only arguments */
+static PyObject *
+c2py_free(arg)
+	anything arg;
+{
+	if ( arg )
+		free((char *)arg);
+	return 0;
+}
+
+/*
+** None
+*/
+static PyObject *
+c2py_none(arg)
+	anything arg;
+{
+	if ( arg )
+		free((char *)arg);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/*
+** OSErr
+*/
+static PyObject *
+c2py_oserr(arg)
+	anything arg;
+{
+	OSErr *ptr = (OSErr *)arg;
+	
+	PARANOID(arg);
+	if (*ptr) {
+		PyErr_Mac(PyMac_OSErrException, *ptr);
+		free(ptr);
+		return NULL;
+	}
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/*
+** integers of all sizes (PPC only)
+*/
+static anything
+py2c_in_int(arg)
+	PyObject  *arg;
+{
+	return PyInt_AsLong(arg);
+}
+
+static PyObject *
+c2py_out_long(arg)
+	anything arg;
+{
+	PyObject *rv;
+	
+	PARANOID(arg);
+	rv = PyInt_FromLong(*(long *)arg);
+	free((char *)arg);
+	return rv;
+}
+
+static PyObject *
+c2py_out_short(arg)
+	anything arg;
+{
+	PyObject *rv;
+	
+	PARANOID(arg);
+	rv =  PyInt_FromLong((long)*(short *)arg);
+	free((char *)arg);
+	return rv;
+}
+
+static PyObject *
+c2py_out_byte(arg)
+	anything arg;
+{
+	PyObject *rv;
+	
+	PARANOID(arg);
+	rv =  PyInt_FromLong((long)*(char *)arg);
+	free((char *)arg);
+	return rv;
+}
+
+/*
+** Strings
+*/
+static anything
+py2c_in_string(arg)
+	PyObject *arg;
+{
+	return (anything)PyString_AsString(arg);
+}
+
+/*
+** Pascal-style strings
+*/
+static anything
+py2c_in_pstring(arg)
+	PyObject *arg;
+{
+	unsigned char *p;
+	int size;
+	
+	if( (size = PyString_Size(arg)) < 0)
+		return 0;
+	if ( size > 255 ) {
+		PyErr_SetString(ErrorObject, "Pstring must be <= 255 chars");
+		return 0;
+	}
+	if( (p=(unsigned char *)malloc(256)) == 0 ) {
+		PyErr_NoMemory();
+		return 0;
+	}
+	p[0] = size;
+	memcpy(p+1, PyString_AsString(arg), size);
+	return (anything)p;
+}
+
+static anything
+py2c_out_pstring(arg)
+	PyObject *arg;
+{
+	unsigned char *p;
+	
+	if( (p=(unsigned char *)malloc(256)) == 0 ) {
+		PyErr_NoMemory();
+		return 0;
+	}
+	p[0] = 0;
+	return (anything)p;
+}
+
+static PyObject *
+c2py_out_pstring(arg)
+	anything arg;
+{
+	unsigned char *p = (unsigned char *)arg;
+	PyObject *rv;
+	
+	PARANOID(arg);
+	rv = PyString_FromStringAndSize((char *)p+1, p[0]);
+	free(p);
+	return rv;
+}
+
+/*
+** C objects.
+*/
+static anything
+py2c_in_cobject(arg)
+	PyObject *arg;
+{
+	if ( arg == Py_None )
+		return 0;
+	return (anything)PyCObject_AsVoidPtr(arg);
+}
+
+static PyObject *
+c2py_out_cobject(arg)
+	anything arg;
+{
+	void **ptr = (void **)arg;
+	PyObject *rv;
+	
+	PARANOID(arg);
+	if ( *ptr == 0 ) {
+		Py_INCREF(Py_None);
+		rv = Py_None;
+	} else {
+		rv = PyCObject_FromVoidPtr(*ptr, 0);
+	}
+	free((char *)ptr);
+	return rv;
+}
+
+/*
+** Handles.
+*/
+static anything
+py2c_in_handle(arg)
+	PyObject *arg;
+{
+	Handle h = 0;
+	ResObj_Convert(arg, &h);
+	return (anything)h;
+}
+
+static PyObject *
+c2py_out_handle(arg)
+	anything arg;
+{
+	Handle *rv = (Handle *)arg;
+	PyObject *prv;
+	
+	PARANOID(arg);
+	if ( *rv == 0 ) {
+		Py_INCREF(Py_None);
+		prv = Py_None;
+	} else {
+		prv = ResObj_New(*rv);
+	}
+	free((char *)rv);
+	return prv;
+}
+
+typedef struct {
+	char *name;		/* Name */
+	py2c_converter	get;	/* Get argument */
+	int	get_uses_arg;	/* True if the above consumes an argument */
+	c2py_converter	put;	/* Put result value */
+	int	put_gives_result;	/* True if above produces a result */
+} conventry;
+
+static conventry converters[] = {
+	{"OutNone",	py2c_alloc,	0,	c2py_none,	1},
+	{"OutOSErr",	py2c_alloc,	0,	c2py_oserr,	1},
+#define OSERRORCONVERTER (&converters[1])
+	{"InInt",	py2c_in_int,	1,	c2py_dummy,	0},
+	{"OutLong",	py2c_alloc,	0,	c2py_out_long,	1},
+	{"OutShort",	py2c_alloc,	0,	c2py_out_short,	1},
+	{"OutByte",	py2c_alloc,	0,	c2py_out_byte,	1},
+	{"InString",	py2c_in_string,	1,	c2py_dummy,	0},
+	{"InPstring",	py2c_in_pstring,1,	c2py_free,	0},
+	{"OutPstring",	py2c_out_pstring,0,	c2py_out_pstring,1},
+	{"InCobject",	py2c_in_cobject,1,	c2py_dummy,	0},
+	{"OutCobject",	py2c_alloc,	0,	c2py_out_cobject,0},
+	{"InHandle",	py2c_in_handle,	1,	c2py_dummy,	0},
+	{"OutHandle",	py2c_alloc,	0,	c2py_out_handle,1},
+	{0, 0, 0, 0, 0}
+};
+
+static conventry *
+getconverter(name)
+	char *name;
+{
+	int i;
+	char buf[256];
+	
+	for(i=0; converters[i].name; i++ )
+		if ( strcmp(name, converters[i].name) == 0 )
+			return &converters[i];
+	sprintf(buf, "Unknown argtype: %s", name);
+	PyErr_SetString(ErrorObject, buf);
+	return 0;
+}	
+
+static int
+argparse_conv(obj, ptr)
+	PyObject *obj;
+	conventry **ptr;
+{
+	char *name;
+	int i;
+	conventry *item;
+	
+	if( (name=PyString_AsString(obj)) == NULL )
+		return 0;
+	if( (item=getconverter(name)) == NULL )
+		return 0;
+	*ptr = item;
+	return 1;
+}
+
+/* ----------------------------------------------------- */
+
+/* Declarations for objects of type fragment */
+
+typedef struct {
+	PyObject_HEAD
+	CFragConnectionID conn_id;
+	char name[MAXNAME+1];
+} cdfobject;
+
+staticforward PyTypeObject Cdftype;
+
+
+
+/* ---------------------------------------------------------------- */
+
+/* Declarations for objects of type routine */
+
+typedef struct {
+	PyObject_HEAD
+	anyroutine rtn;
+	char name[MAXNAME+1];
+} cdrobject;
+
+staticforward PyTypeObject Cdrtype;
+
+
+
+/* ---------------------------------------------------------------- */
+
+/* Declarations for objects of type callable */
+
+typedef struct {
+	PyObject_HEAD
+	cdrobject *routine;	/* The routine to call */
+	int npargs;		/* Python argument count */
+	int npreturn;		/* Python return value count */
+	int ncargs;		/* C argument count + 1 */
+	conventry *argconv[MAXARG+1];	/* Value converter list */
+} cdcobject;
+
+staticforward PyTypeObject Cdctype;
+
+
+
+/* -------------------------------------------------------- */
+
+
+static struct PyMethodDef cdr_methods[] = {
+	
+	{NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+static cdrobject *
+newcdrobject(name, routine)
+	unsigned char *name;
+	anyroutine routine;
+{
+	cdrobject *self;
+	int nlen;
+	
+	self = PyObject_NEW(cdrobject, &Cdrtype);
+	if (self == NULL)
+		return NULL;
+	if ( name[0] > MAXNAME )
+		nlen = MAXNAME;
+	else
+		nlen = name[0];
+	memcpy(self->name, name+1, nlen);
+	self->name[nlen] = '\0';
+	self->rtn = routine;
+	return self;
+}
+
+static void
+cdr_dealloc(self)
+	cdrobject *self;
+{
+	PyMem_DEL(self);
+}
+
+static PyObject *
+cdr_repr(self)
+	cdrobject *self;
+{
+	PyObject *s;
+	char buf[256];
+
+	sprintf(buf, "<Calldll routine %s address 0x%x>", self->name, self->rtn);
+	s = PyString_FromString(buf);
+	return s;
+}
+
+static char Cdrtype__doc__[] = 
+"C Routine address"
+;
+
+static PyTypeObject Cdrtype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,				/*ob_size*/
+	"routine",			/*tp_name*/
+	sizeof(cdrobject),		/*tp_basicsize*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)cdr_dealloc,	/*tp_dealloc*/
+	(printfunc)0,			/*tp_print*/
+	(getattrfunc)0,			/*tp_getattr*/
+	(setattrfunc)0,			/*tp_setattr*/
+	(cmpfunc)0,			/*tp_compare*/
+	(reprfunc)cdr_repr,		/*tp_repr*/
+	0,				/*tp_as_number*/
+	0,				/*tp_as_sequence*/
+	0,				/*tp_as_mapping*/
+	(hashfunc)0,			/*tp_hash*/
+	(ternaryfunc)0,			/*tp_call*/
+	(reprfunc)0,			/*tp_str*/
+
+	/* Space for future expansion */
+	0L,0L,0L,0L,
+	Cdrtype__doc__ /* Documentation string */
+};
+
+/* End of code for routine objects */
+/* -------------------------------------------------------- */
+
+
+static struct PyMethodDef cdc_methods[] = {
+	
+	{NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+static cdcobject *
+newcdcobject(routine, npargs, npreturn, ncargs, argconv)
+	cdrobject *routine;
+	int npargs;
+	int npreturn;
+	int ncargs;
+	conventry *argconv[];
+{
+	cdcobject *self;
+	int i;
+	
+	self = PyObject_NEW(cdcobject, &Cdctype);
+	if (self == NULL)
+		return NULL;
+	self->routine = routine;
+	Py_INCREF(routine);
+	self->npargs = npargs;
+	self->npreturn = npreturn;
+	self->ncargs = ncargs;
+	for(i=0; i<MAXARG+1; i++)
+		if ( i < ncargs )
+			self->argconv[i] = argconv[i];
+		else
+			self->argconv[i] = 0;
+	return self;
+}
+
+static void
+cdc_dealloc(self)
+	cdcobject *self;
+{
+	Py_XDECREF(self->routine);
+	PyMem_DEL(self);
+}
+
+
+static PyObject *
+cdc_repr(self)
+	cdcobject *self;
+{
+	PyObject *s;
+	char buf[256];
+	int i;
+	
+	sprintf(buf, "<callable %s = %s(", self->argconv[0]->name, self->routine->name);
+	for(i=1; i< self->ncargs; i++) {
+		strcat(buf, self->argconv[i]->name);
+		if ( i < self->ncargs-1 )
+			strcat(buf, ", ");
+	}
+	strcat(buf, ") >");
+
+	s = PyString_FromString(buf);
+	return s;
+}
+
+/*
+** And this is what we all do it for: call a C function.
+*/
+static PyObject *
+cdc_call(self, args, kwargs)
+	cdcobject *self;
+	PyObject *args;
+	PyObject *kwargs;
+{
+	char buf[256];
+	int i, pargindex;
+	anything c_args[MAXARG+1] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+	conventry *cp;
+	PyObject *curarg;
+	anyroutine func;
+	PyObject *rv0, *rv;
+	
+	if( kwargs ) {
+		PyErr_SetString(PyExc_TypeError, "Keyword args not allowed");
+		return 0;
+	}
+	if( !PyTuple_Check(args) ) {
+		PyErr_SetString(PyExc_TypeError, "Arguments not in tuple");
+		return 0;
+	}
+	if( PyTuple_Size(args) != self->npargs ) {
+		sprintf(buf, "%d arguments, expected %d", PyTuple_Size(args), self->npargs);
+		PyErr_SetString(PyExc_TypeError, buf);
+		return 0;
+	}
+	
+	/* Decode arguments */
+	pargindex = 0;
+	for(i=0; i<self->ncargs; i++) {
+		cp = self->argconv[i];
+		if ( cp->get_uses_arg ) {
+			curarg = PyTuple_GET_ITEM(args, pargindex);
+			pargindex++;
+		} else {
+			curarg = (PyObject *)NULL;
+		}
+		c_args[i] = (*cp->get)(curarg);
+	}
+	if (PyErr_Occurred())
+		return 0;
+		
+	/* Call function */
+	func = self->routine->rtn;
+	*(anything *)c_args[0] = (*func)(c_args[1], c_args[2], c_args[3], c_args[4],
+			c_args[5], c_args[6], c_args[7], c_args[8]);
+
+	/* Build return tuple (always a tuple, for now */
+	if( (rv=PyTuple_New(self->npreturn)) == NULL )
+		return NULL;
+	pargindex = 0;
+	for(i=0; i<self->ncargs; i++) {
+		cp = self->argconv[i];
+		curarg = (*cp->put)(c_args[i]);
+		if( cp->put_gives_result )
+			PyTuple_SET_ITEM(rv, pargindex, curarg);
+		/* NOTE: We only check errors at the end (so we free() everything) */
+	}
+	if ( PyErr_Occurred() ) {
+		Py_DECREF(rv);
+		return NULL;
+	}
+	return rv;
+}
+
+static char Cdctype__doc__[] = 
+""
+;
+
+static PyTypeObject Cdctype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,				/*ob_size*/
+	"callable",			/*tp_name*/
+	sizeof(cdcobject),		/*tp_basicsize*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)cdc_dealloc,	/*tp_dealloc*/
+	(printfunc)0,			/*tp_print*/
+	(getattrfunc)0,			/*tp_getattr*/
+	(setattrfunc)0,			/*tp_setattr*/
+	(cmpfunc)0,			/*tp_compare*/
+	(reprfunc)cdc_repr,		/*tp_repr*/
+	0,				/*tp_as_number*/
+	0,				/*tp_as_sequence*/
+	0,				/*tp_as_mapping*/
+	(hashfunc)0,			/*tp_hash*/
+	(ternaryfunc)cdc_call,		/*tp_call*/
+	(reprfunc)0,			/*tp_str*/
+
+	/* Space for future expansion */
+	0L,0L,0L,0L,
+	Cdctype__doc__ /* Documentation string */
+};
+
+/* End of code for callable objects */
+/* ---------------------------------------------------------------- */
+
+static struct PyMethodDef cdf_methods[] = {
+	
+	{NULL,		NULL}		/* sentinel */
+};
+
+/* ---------- */
+
+
+static cdfobject *
+newcdfobject(conn_id, name)
+	CFragConnectionID conn_id;
+	unsigned char *name;
+{
+	cdfobject *self;
+	int nlen;
+	
+	self = PyObject_NEW(cdfobject, &Cdftype);
+	if (self == NULL)
+		return NULL;
+	self->conn_id = conn_id;
+	if ( name[0] > MAXNAME )
+		nlen = MAXNAME;
+	else
+		nlen = name[0];
+	strncpy(self->name, (char *)name+1, nlen);
+	self->name[nlen] = '\0';
+	return self;
+}
+
+static void
+cdf_dealloc(self)
+	cdfobject *self;
+{
+	PyMem_DEL(self);
+}
+
+static PyObject *
+cdf_repr(self)
+	cdfobject *self;
+{
+	PyObject *s;
+	char buf[256];
+
+	sprintf(buf, "<fragment %s connection, id 0x%x>", self->name, self->conn_id);
+	s = PyString_FromString(buf);
+	return s;
+}
+
+static PyObject *
+cdf_getattr(self, name)
+	cdfobject *self;
+	char *name;
+{
+	unsigned char *rtn_name;
+	anyroutine rtn;
+	OSErr err;
+	Str255 errMessage;
+	CFragSymbolClass class;
+	char buf[256];
+	
+	rtn_name = Pstring(name);
+	err = FindSymbol(self->conn_id, rtn_name, (Ptr *)&rtn, &class);
+	if ( err ) {
+		sprintf(buf, "%.*s: %s", rtn_name[0], rtn_name+1, PyMac_StrError(err));
+		PyErr_SetString(ErrorObject, buf);
+		return NULL;
+	}
+	if( class != kTVectorCFragSymbol ) {
+		PyErr_SetString(ErrorObject, "Symbol is not a routine");
+		return NULL;
+	}
+	
+	return (PyObject *)newcdrobject(rtn_name, rtn);
+}
+/* -------------------------------------------------------- */
+
+static char Cdftype__doc__[] = 
+"Code Fragment library symbol table"
+;
+
+static PyTypeObject Cdftype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,				/*ob_size*/
+	"fragment",			/*tp_name*/
+	sizeof(cdfobject),		/*tp_basicsize*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)cdf_dealloc,	/*tp_dealloc*/
+	(printfunc)0,			/*tp_print*/
+	(getattrfunc)cdf_getattr,	/*tp_getattr*/
+	(setattrfunc)0,			/*tp_setattr*/
+	(cmpfunc)0,			/*tp_compare*/
+	(reprfunc)cdf_repr,		/*tp_repr*/
+	0,				/*tp_as_number*/
+	0,				/*tp_as_sequence*/
+	0,				/*tp_as_mapping*/
+	(hashfunc)0,			/*tp_hash*/
+	(ternaryfunc)0,			/*tp_call*/
+	(reprfunc)0,			/*tp_str*/
+
+	/* Space for future expansion */
+	0L,0L,0L,0L,
+	Cdftype__doc__ /* Documentation string */
+};
+
+/* End of code for fragment objects */
+/* -------------------------------------------------------- */
+
+
+static char cdll_getlibrary__doc__[] =
+"Load a shared library fragment and return the symbol table"
+;
+
+static PyObject *
+cdll_getlibrary(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	Str255 frag_name;
+	OSErr err;
+	Str255 errMessage;
+	Ptr main_addr;
+	CFragConnectionID conn_id;
+	char buf[256];
+	
+	if (!PyArg_ParseTuple(args, "O&", PyMac_GetStr255, frag_name))
+		return NULL;
+
+	/* Find the library connection ID */
+	err = GetSharedLibrary(frag_name, kCurrentCFragArch, kLoadCFrag, &conn_id, &main_addr, 
+			errMessage);
+	if ( err ) {
+		sprintf(buf, "%.*s: %s", errMessage[0], errMessage+1, PyMac_StrError(err));
+		PyErr_SetString(ErrorObject, buf);
+		return NULL;
+	}
+	return (PyObject *)newcdfobject(conn_id, frag_name);
+}
+
+static char cdll_getdiskfragment__doc__[] =
+"Load a fragment from a disk file and return the symbol table"
+;
+
+static PyObject *
+cdll_getdiskfragment(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	FSSpec fsspec;
+	Str255 frag_name;
+	OSErr err;
+	Str255 errMessage;
+	Ptr main_addr;
+	CFragConnectionID conn_id;
+	char buf[256];
+	Boolean isfolder, didsomething;
+	
+	if (!PyArg_ParseTuple(args, "O&O&", PyMac_GetFSSpec, &fsspec,
+			PyMac_GetStr255, frag_name))
+		return NULL;
+	err = ResolveAliasFile(&fsspec, 1, &isfolder, &didsomething);
+	if ( err )
+		return PyErr_Mac(ErrorObject, err);
+
+	/* Load the fragment (or return the connID if it is already loaded */
+	err = GetDiskFragment(&fsspec, 0, 0, frag_name, 
+			      kLoadCFrag, &conn_id, &main_addr,
+			      errMessage);
+	if ( err ) {
+		sprintf(buf, "%.*s: %s", errMessage[0], errMessage+1, PyMac_StrError(err));
+		PyErr_SetString(ErrorObject, buf);
+		return NULL;
+	}
+	return (PyObject *)newcdfobject(conn_id, frag_name);
+}
+
+static char cdll_newcall__doc__[] =
+""
+;
+
+static PyObject *
+cdll_newcall(self, args)
+	PyObject *self;	/* Not used */
+	PyObject *args;
+{
+	cdrobject *routine;
+	conventry *argconv[MAXARG+1] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+	int npargs, npreturn, ncargs;
+
+	/* Note: the next format depends on MAXARG+1 */
+	if (!PyArg_ParseTuple(args, "O!O&|O&O&O&O&O&O&O&O&", &Cdrtype, &routine,
+		argparse_conv, &argconv[0], argparse_conv, &argconv[1],
+		argparse_conv, &argconv[2], argparse_conv, &argconv[3],
+		argparse_conv, &argconv[4], argparse_conv, &argconv[5],
+		argparse_conv, &argconv[6], argparse_conv, &argconv[7],
+		argparse_conv, &argconv[8]))
+		return NULL;
+	npargs = npreturn = 0;
+	for(ncargs=0; ncargs < MAXARG+1 && argconv[ncargs]; ncargs++) {
+		if( argconv[ncargs]->get_uses_arg ) npargs++;
+		if( argconv[ncargs]->put_gives_result ) npreturn++;
+	}
+	return (PyObject *)newcdcobject(routine, npargs, npreturn, ncargs, argconv);
+}
+
+/* List of methods defined in the module */
+
+static struct PyMethodDef cdll_methods[] = {
+	{"getlibrary",		(PyCFunction)cdll_getlibrary,		METH_VARARGS,	
+							cdll_getlibrary__doc__},
+	{"getdiskfragment",	(PyCFunction)cdll_getdiskfragment,	METH_VARARGS,
+							cdll_getdiskfragment__doc__},
+	{"newcall",		(PyCFunction)cdll_newcall,		METH_VARARGS,
+							cdll_newcall__doc__},
+ 
+	{NULL,	 (PyCFunction)NULL, 0, NULL}		/* sentinel */
+};
+
+
+/* Initialization function for the module (*must* be called initcalldll) */
+
+static char calldll_module_documentation[] = 
+""
+;
+
+void
+initcalldll()
+{
+	PyObject *m, *d;
+
+	/* Create the module and add the functions */
+	m = Py_InitModule4("calldll", cdll_methods,
+		calldll_module_documentation,
+		(PyObject*)NULL,PYTHON_API_VERSION);
+
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	ErrorObject = PyString_FromString("calldll.error");
+	PyDict_SetItemString(d, "error", ErrorObject);
+
+	/* XXXX Add constants here */
+	
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module calldll");
+}
+
+/* Test routine */
+int calldlltester(int a1,int  a2,int  a3,int  a4,int  a5,int  a6,int  a7,int  a8)
+{
+	printf("Tester1: %x %x %x %x %x %x %x %x\n", a1, a2, a3, a4, a5, a6, a7, a8);
+	return a1;
+}
+