diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Modules/cstubs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Modules/cstubs	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,1364 @@
+
+/*
+Input used to generate the Python module "glmodule.c".
+The stub generator is a Python script called "cgen.py".
+
+Each definition must be contained on one line:
+
+<returntype> <name> <type> <arg> <type> <arg>
+
+<returntype> can be: void, short, long (XXX maybe others?)
+
+<type> can be: char, string, short, float, long, or double
+	string indicates a null terminated string;
+	if <type> is char and <arg> begins with a *, the * is stripped
+	and <type> is changed into string
+
+<arg> has the form <mode> or <mode>[<subscript>]
+	where <mode> can be
+		s: arg is sent
+		r: arg is received		(arg is a pointer)
+	and <subscript> can be (N and I are numbers):
+		N
+		argI
+		retval
+		N*argI
+		N*I
+		N*retval
+	In the case where the subscript consists of two parts
+	separated by *, the first part is the width of the matrix, and
+	the second part is the length of the matrix.  This order is
+	opposite from the order used in C to declare a two-dimensional
+	matrix.
+*/
+
+/*
+ * An attempt has been made to make this module switch threads on qread
+ * calls. It is far from safe, though.
+ */
+
+#include <gl.h>
+#include <device.h>
+
+#ifdef __sgi
+extern int devport();
+extern int textwritemask();
+extern int pagewritemask();
+extern int gewrite();
+extern int gettp();
+#endif
+
+#include "Python.h"
+#include "cgensupport.h"
+
+/*
+Some stubs are too complicated for the stub generator.
+We can include manually written versions of them here.
+A line starting with '%' gives the name of the function so the stub
+generator can include it in the table of functions.
+*/
+
+% qread
+
+static PyObject *
+gl_qread(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	long retval;
+	short arg1 ;
+	Py_BEGIN_ALLOW_THREADS
+	retval = qread( & arg1 );
+	Py_END_ALLOW_THREADS
+	{ PyObject *v = PyTuple_New( 2 );
+	  if (v == NULL) return NULL;
+	  PyTuple_SetItem(v, 0, mknewlongobject(retval));
+	  PyTuple_SetItem(v, 1, mknewshortobject(arg1));
+	  return v;
+	}
+}
+
+
+/*
+varray -- an array of v.. calls.
+The argument is an array (maybe list or tuple) of points.
+Each point must be a tuple or list of coordinates (x, y, z).
+The points may be 2- or 3-dimensional but must all have the
+same dimension.  Float and int values may be mixed however.
+The points are always converted to 3D double precision points
+by assuming z=0.0 if necessary (as indicated in the man page),
+and for each point v3d() is called.
+*/
+
+% varray
+
+static PyObject *
+gl_varray(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	PyObject *v, *w=NULL;
+	int i, n, width;
+	double vec[3];
+	PyObject * (*getitem)(PyObject *, int);
+	
+	if (!PyArg_GetObject(args, 1, 0, &v))
+		return NULL;
+	
+	if (PyList_Check(v)) {
+		n = PyList_Size(v);
+		getitem = PyList_GetItem;
+	}
+	else if (PyTuple_Check(v)) {
+		n = PyTuple_Size(v);
+		getitem = PyTuple_GetItem;
+	}
+	else {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	
+	if (n == 0) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+	if (n > 0)
+		w = (*getitem)(v, 0);
+	
+	width = 0;
+	if (w == NULL) {
+	}
+	else if (PyList_Check(w)) {
+		width = PyList_Size(w);
+	}
+	else if (PyTuple_Check(w)) {
+		width = PyTuple_Size(w);
+	}
+	
+	switch (width) {
+	case 2:
+		vec[2] = 0.0;
+		/* Fall through */
+	case 3:
+		break;
+	default:
+		PyErr_BadArgument();
+		return NULL;
+	}
+	
+	for (i = 0; i < n; i++) {
+		w = (*getitem)(v, i);
+		if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
+			return NULL;
+		v3d(vec);
+	}
+	
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/*
+vnarray, nvarray -- an array of n3f and v3f calls.
+The argument is an array (list or tuple) of pairs of points and normals.
+Each pair is a tuple (NOT a list) of a point and a normal for that point.
+Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
+Three coordinates must be given.  Float and int values may be mixed.
+For each pair, n3f() is called for the normal, and then v3f() is called
+for the vector.
+
+vnarray and nvarray differ only in the order of the vector and normal in
+the pair: vnarray expects (v, n) while nvarray expects (n, v).
+*/
+
+static PyObject *gen_nvarray(); /* Forward */
+
+% nvarray
+
+static PyObject *
+gl_nvarray(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	return gen_nvarray(args, 0);
+}
+
+% vnarray
+
+static PyObject *
+gl_vnarray(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	return gen_nvarray(args, 1);
+}
+
+/* Generic, internal version of {nv,nv}array: inorm indicates the
+   argument order, 0: normal first, 1: vector first. */
+
+static PyObject *
+gen_nvarray(args, inorm)
+	PyObject *args;
+	int inorm;
+{
+	PyObject *v, *w, *wnorm, *wvec;
+	int i, n;
+	float norm[3], vec[3];
+	PyObject * (*getitem)(PyObject *, int);
+	
+	if (!PyArg_GetObject(args, 1, 0, &v))
+		return NULL;
+	
+	if (PyList_Check(v)) {
+		n = PyList_Size(v);
+		getitem = PyList_GetItem;
+	}
+	else if (PyTuple_Check(v)) {
+		n = PyTuple_Size(v);
+		getitem = PyTuple_GetItem;
+	}
+	else {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	
+	for (i = 0; i < n; i++) {
+		w = (*getitem)(v, i);
+		if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {
+			PyErr_BadArgument();
+			return NULL;
+		}
+		wnorm = PyTuple_GetItem(w, inorm);
+		wvec = PyTuple_GetItem(w, 1 - inorm);
+		if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
+			!PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
+			return NULL;
+		n3f(norm);
+		v3f(vec);
+	}
+	
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
+   The dimensions of ctl[] are computed as follows:
+   [len(s_knots) - s_order], [len(t_knots) - t_order]
+*/
+
+% nurbssurface
+
+static PyObject *
+gl_nurbssurface(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	long arg1 ;
+	double * arg2 ;
+	long arg3 ;
+	double * arg4 ;
+	double *arg5 ;
+	long arg6 ;
+	long arg7 ;
+	long arg8 ;
+	long ncoords;
+	long s_byte_stride, t_byte_stride;
+	long s_nctl, t_nctl;
+	long s, t;
+	PyObject *v, *w, *pt;
+	double *pnext;
+	if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
+		return NULL;
+	if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
+		return PyErr_NoMemory();
+	}
+	if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
+		return NULL;
+	if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
+		return NULL;
+	if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {
+		return PyErr_NoMemory();
+	}
+	if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
+		return NULL;
+	if (!PyArg_GetLong(args, 6, 3, &arg6))
+		return NULL;
+	if (!PyArg_GetLong(args, 6, 4, &arg7))
+		return NULL;
+	if (!PyArg_GetLong(args, 6, 5, &arg8))
+		return NULL;
+	if (arg8 == N_XYZ)
+		ncoords = 3;
+	else if (arg8 == N_XYZW)
+		ncoords = 4;
+	else {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	s_nctl = arg1 - arg6;
+	t_nctl = arg3 - arg7;
+	if (!PyArg_GetObject(args, 6, 2, &v))
+		return NULL;
+	if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
+		return PyErr_NoMemory();
+	}
+	pnext = arg5;
+	for (s = 0; s < s_nctl; s++) {
+		w = PyList_GetItem(v, s);
+		if (w == NULL || !PyList_Check(w) ||
+					PyList_Size(w) != t_nctl) {
+			PyErr_BadArgument();
+			return NULL;
+		}
+		for (t = 0; t < t_nctl; t++) {
+			pt = PyList_GetItem(w, t);
+			if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
+				return NULL;
+			pnext += ncoords;
+		}
+	}
+	s_byte_stride = sizeof(double) * ncoords;
+	t_byte_stride = s_byte_stride * s_nctl;
+	nurbssurface( arg1 , arg2 , arg3 , arg4 ,
+		s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
+	PyMem_DEL(arg2);
+	PyMem_DEL(arg4);
+	PyMem_DEL(arg5);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* nurbscurve(knots, ctlpoints, order, type).
+   The length of ctlpoints is len(knots)-order. */
+
+%nurbscurve
+
+static PyObject *
+gl_nurbscurve(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	long arg1 ;
+	double * arg2 ;
+	long arg3 ;
+	double * arg4 ;
+	long arg5 ;
+	long arg6 ;
+	int ncoords, npoints;
+	int i;
+	PyObject *v;
+	double *pnext;
+	if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
+		return NULL;
+	if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
+		return PyErr_NoMemory();
+	}
+	if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 2, &arg5))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 3, &arg6))
+		return NULL;
+	if (arg6 == N_ST)
+		ncoords = 2;
+	else if (arg6 == N_STW)
+		ncoords = 3;
+	else {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	npoints = arg1 - arg5;
+	if (!PyArg_GetObject(args, 4, 1, &v))
+		return NULL;
+	if (!PyList_Check(v) || PyList_Size(v) != npoints) {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {
+		return PyErr_NoMemory();
+	}
+	pnext = arg4;
+	for (i = 0; i < npoints; i++) {
+		if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
+			return NULL;
+		pnext += ncoords;
+	}
+	arg3 = (sizeof(double)) * ncoords;
+	nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
+	PyMem_DEL(arg2);
+	PyMem_DEL(arg4);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* pwlcurve(points, type).
+   Points is a list of points. Type must be N_ST. */
+
+%pwlcurve
+
+static PyObject *
+gl_pwlcurve(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	PyObject *v;
+	long type;
+	double *data, *pnext;
+	long npoints, ncoords;
+	int i;
+	if (!PyArg_GetObject(args, 2, 0, &v))
+		return NULL;
+	if (!PyArg_GetLong(args, 2, 1, &type))
+		return NULL;
+	if (!PyList_Check(v)) {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	npoints = PyList_Size(v);
+	if (type == N_ST)
+		ncoords = 2;
+	else {
+		PyErr_BadArgument();
+		return NULL;
+	}
+	if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {
+		return PyErr_NoMemory();
+	}
+	pnext = data;
+	for (i = 0; i < npoints; i++) {
+		if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
+			return NULL;
+		pnext += ncoords;
+	}
+	pwlcurve(npoints, data, sizeof(double)*ncoords, type);
+	PyMem_DEL(data);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+
+/* Picking and Selecting */
+
+static short *pickbuffer = NULL;
+static long pickbuffersize;
+
+static PyObject *
+pick_select(args, func)
+	PyObject *args;
+	void (*func)();
+{
+	if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
+		return NULL;
+	if (pickbuffer != NULL) {
+		PyErr_SetString(PyExc_RuntimeError,
+			"pick/gselect: already picking/selecting");
+		return NULL;
+	}
+	if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {
+		return PyErr_NoMemory();
+	}
+	(*func)(pickbuffer, pickbuffersize);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+endpick_select(args, func)
+	PyObject *args;
+	long (*func)();
+{
+	PyObject *v, *w;
+	int i, nhits, n;
+	if (!PyArg_NoArgs(args))
+		return NULL;
+	if (pickbuffer == NULL) {
+		PyErr_SetString(PyExc_RuntimeError,
+			"endpick/endselect: not in pick/select mode");
+		return NULL;
+	}
+	nhits = (*func)(pickbuffer);
+	if (nhits < 0) {
+		nhits = -nhits; /* How to report buffer overflow otherwise? */
+	}
+	/* Scan the buffer to see how many integers */
+	n = 0;
+	for (; nhits > 0; nhits--) {
+		n += 1 + pickbuffer[n];
+	}
+	v = PyList_New(n);
+	if (v == NULL)
+		return NULL;
+	/* XXX Could do it nicer and interpret the data structure here,
+	   returning a list of lists. But this can be done in Python... */
+	for (i = 0; i < n; i++) {
+		w = PyInt_FromLong((long)pickbuffer[i]);
+		if (w == NULL) {
+			Py_DECREF(v);
+			return NULL;
+		}
+		PyList_SetItem(v, i, w);
+	}
+	PyMem_DEL(pickbuffer);
+	pickbuffer = NULL;
+	return v;
+}
+
+extern void pick(), gselect();
+extern long endpick(), endselect();
+
+%pick
+static PyObject *gl_pick(self, args) PyObject *self, *args; {
+	return pick_select(args, pick);
+}
+
+%endpick
+static PyObject *gl_endpick(self, args) PyObject *self, *args; {
+	return endpick_select(args, endpick);
+}
+
+%gselect
+static PyObject *gl_gselect(self, args) PyObject *self, *args; {
+	return pick_select(args, gselect);
+}
+
+%endselect
+static PyObject *gl_endselect(self, args) PyObject *self, *args; {
+	return endpick_select(args, endselect);
+}
+
+
+/* XXX The generator botches this one.  Here's a quick hack to fix it. */
+
+/* XXX The generator botches this one.  Here's a quick hack to fix it. */
+
+% getmatrix float r[16]
+
+static PyObject *
+gl_getmatrix(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	Matrix arg1;
+	PyObject *v, *w;
+	int i, j;
+	getmatrix( arg1 );
+	v = PyList_New(16);
+	if (v == NULL) {
+		return PyErr_NoMemory();
+	}
+	for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
+		w = mknewfloatobject(arg1[i][j]);
+		if (w == NULL) {
+			Py_DECREF(v);
+			return NULL;
+		}
+		PyList_SetItem(v, i*4+j, w);
+	}
+	return v;
+}
+
+/* Here's an alternate version that returns a 4x4 matrix instead of
+   a vector.  Unfortunately it is incompatible with loadmatrix and
+   multmatrix... */
+
+% altgetmatrix float r[4][4]
+
+static PyObject *
+gl_altgetmatrix(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	Matrix arg1;
+	PyObject *v, *w;
+	int i, j;
+	getmatrix( arg1 );
+	v = PyList_New(4);
+	if (v == NULL) {
+		return NULL;
+	}
+	for (i = 0; i < 4; i++) {
+		w = PyList_New(4);
+		if (w == NULL) {
+			Py_DECREF(v);
+			return NULL;
+		}
+		PyList_SetItem(v, i, w);
+	}
+	for (i = 0; i < 4; i++) {
+		for (j = 0; j < 4; j++) {
+			w = mknewfloatobject(arg1[i][j]);
+			if (w == NULL) {
+				Py_DECREF(v);
+				return NULL;
+			}
+			PyList_SetItem(PyList_GetItem(v, i), j, w);
+		}
+	}
+	return v;
+}
+
+% lrectwrite
+
+static PyObject *
+gl_lrectwrite(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	short x1 ;
+	short y1 ;
+	short x2 ;
+	short y2 ;
+	string parray ;
+	PyObject *s;
+#if 0
+	int pixcount;
+#endif
+	if (!PyArg_GetShort(args, 5, 0, &x1))
+		return NULL;
+	if (!PyArg_GetShort(args, 5, 1, &y1))
+		return NULL;
+	if (!PyArg_GetShort(args, 5, 2, &x2))
+		return NULL;
+	if (!PyArg_GetShort(args, 5, 3, &y2))
+		return NULL;
+	if (!PyArg_GetString(args, 5, 4, &parray))
+		return NULL;
+	if (!PyArg_GetObject(args, 5, 4, &s))
+		return NULL;
+#if 0
+/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
+	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
+	if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
+		PyErr_SetString(PyExc_RuntimeError,
+			   "string arg to lrectwrite has wrong size");
+		return NULL;
+	}
+#endif
+	lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+% lrectread
+
+static PyObject *
+gl_lrectread(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	short x1 ;
+	short y1 ;
+	short x2 ;
+	short y2 ;
+	PyObject *parray;
+	int pixcount;
+	if (!PyArg_GetShort(args, 4, 0, &x1))
+		return NULL;
+	if (!PyArg_GetShort(args, 4, 1, &y1))
+		return NULL;
+	if (!PyArg_GetShort(args, 4, 2, &x2))
+		return NULL;
+	if (!PyArg_GetShort(args, 4, 3, &y2))
+		return NULL;
+	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
+	parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+	if (parray == NULL)
+		return NULL; /* No memory */
+	lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
+	return parray;
+}
+
+% readdisplay
+
+static PyObject *
+gl_readdisplay(self, args)
+	PyObject *self;
+        PyObject *args;
+{
+        short x1, y1, x2, y2;
+	unsigned long *parray, hints;
+	long size, size_ret;
+	PyObject *rv;
+
+	if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
+	  return 0;
+	size = (long)(x2+1-x1) * (long)(y2+1-y1);
+	rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
+	if ( rv == NULL )
+	  return NULL;
+	parray = (unsigned long *)PyString_AsString(rv);
+	size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
+	if ( size_ret != size ) {
+	    printf("gl_readdisplay: got %ld pixels, expected %ld\n",
+		   size_ret, size);
+	    PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");
+	    return NULL;
+	}
+	return rv;
+}
+
+/* Desperately needed, here are tools to compress and decompress
+   the data manipulated by lrectread/lrectwrite.
+
+   gl.packrect(width, height, packfactor, bigdata) --> smalldata
+		makes 'bigdata' 4*(packfactor**2) times smaller by:
+		- turning it into B/W (a factor 4)
+		- replacing squares of size pacfactor by one
+		  representative
+
+   gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
+		is the inverse; the numeric arguments must be *the same*.
+
+   Both work best if width and height are multiples of packfactor
+   (in fact unpackrect will leave garbage bytes).
+*/
+
+% packrect
+
+static PyObject *
+gl_packrect(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	long width, height, packfactor;
+	char *s;
+	PyObject *unpacked, *packed;
+	int pixcount, packedcount, x, y, r, g, b;
+	unsigned long pixel;
+	unsigned char *p;
+	unsigned long *parray;
+	if (!PyArg_GetLong(args, 4, 0, &width))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 1, &height))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 2, &packfactor))
+		return NULL;
+	if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
+		return NULL;
+	if (!PyArg_GetObject(args, 4, 3, &unpacked))
+		return NULL;
+	if (width <= 0 || height <= 0 || packfactor <= 0) {
+		PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
+		return NULL;
+	}
+	pixcount = width*height;
+	packedcount = ((width+packfactor-1)/packfactor) *
+		((height+packfactor-1)/packfactor);
+	if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
+		PyErr_SetString(PyExc_RuntimeError,
+			   "string arg to packrect has wrong size");
+		return NULL;
+	}
+	packed = PyString_FromStringAndSize((char *)NULL, packedcount);
+	if (packed == NULL)
+		return NULL;
+	parray = (unsigned long *) PyString_AsString(unpacked);
+	p = (unsigned char *) PyString_AsString(packed);
+	for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
+		for (x = 0; x < width; x += packfactor) {
+			pixel = parray[x];
+			r = pixel & 0xff;
+			g = (pixel >> 8) & 0xff;
+			b = (pixel >> 16) & 0xff;
+			*p++ = (30*r+59*g+11*b) / 100;
+		}
+	}
+	return packed;
+}
+
+% unpackrect
+
+static unsigned long unpacktab[256];
+static int unpacktab_inited = 0;
+
+static PyObject *
+gl_unpackrect(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	long width, height, packfactor;
+	char *s;
+	PyObject *unpacked, *packed;
+	int pixcount, packedcount;
+	register unsigned char *p;
+	register unsigned long *parray;
+	if (!unpacktab_inited) {
+		register int white;
+		for (white = 256; --white >= 0; )
+			unpacktab[white] = white * 0x010101L;
+		unpacktab_inited++;
+	}
+	if (!PyArg_GetLong(args, 4, 0, &width))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 1, &height))
+		return NULL;
+	if (!PyArg_GetLong(args, 4, 2, &packfactor))
+		return NULL;
+	if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
+		return NULL;
+	if (!PyArg_GetObject(args, 4, 3, &packed))
+		return NULL;
+	if (width <= 0 || height <= 0 || packfactor <= 0) {
+		PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
+		return NULL;
+	}
+	pixcount = width*height;
+	packedcount = ((width+packfactor-1)/packfactor) *
+		((height+packfactor-1)/packfactor);
+	if (PyString_Size(packed) != packedcount) {
+		PyErr_SetString(PyExc_RuntimeError,
+			   "string arg to unpackrect has wrong size");
+		return NULL;
+	}
+	unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
+	if (unpacked == NULL)
+		return NULL;
+	parray = (unsigned long *) PyString_AsString(unpacked);
+	p = (unsigned char *) PyString_AsString(packed);
+	if (packfactor == 1 && width*height > 0) {
+		/* Just expand bytes to longs */
+		register int x = width * height;
+		do {
+			*parray++ = unpacktab[*p++];
+		} while (--x >= 0);
+	}
+	else {
+		register int y;
+		for (y = 0; y < height-packfactor+1;
+		     y += packfactor, parray += packfactor*width) {
+			register int x;
+			for (x = 0; x < width-packfactor+1; x += packfactor) {
+				register unsigned long pixel = unpacktab[*p++];
+				register int i;
+				for (i = packfactor*width; (i-=width) >= 0;) {
+					register int j;
+					for (j = packfactor; --j >= 0; )
+						parray[i+x+j] = pixel;
+				}
+			}
+		}
+	}
+	return unpacked;
+}
+
+% gversion
+static PyObject *
+gl_gversion(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	char buf[20];
+	gversion(buf);
+	return PyString_FromString(buf);
+}
+
+
+/* void clear - Manual because of clash with termcap */
+%clear
+static PyObject *
+gl_clear(self, args)
+	PyObject *self;
+	PyObject *args;
+{
+	__GLclear( );
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* End of manually written stubs */
+
+%%
+
+long 	getshade
+if !solaris	void 	devport 	short s long s
+void 	rdr2i 		long s long s
+void	rectfs 		short s short s short s short s
+void 	rects 		short s short s short s short s
+void 	rmv2i 		long s long s
+void	noport
+void	popviewport
+void	clearhitcode
+void	closeobj
+void	cursoff
+void	curson
+void	doublebuffer
+void 	finish
+void	gconfig
+void	ginit
+void	greset
+void	multimap
+void	onemap
+void	popattributes
+void	popmatrix
+void	pushattributes
+void	pushmatrix
+void	pushviewport
+void	qreset
+void	RGBmode
+void	singlebuffer
+void	swapbuffers
+void	gsync
+void	gflush
+void	tpon
+void	tpoff
+void	clkon
+void	clkoff
+void	ringbell
+#void	callfunc
+void	gbegin
+void	textinit
+void	initnames
+void	pclos
+void	popname
+if !solaris	void	spclos
+void	zclear
+void	screenspace
+void	reshapeviewport
+void	winpush
+void	winpop
+void	foreground
+void	endfullscrn
+if !solaris	void	endpupmode
+void	fullscrn
+if !solaris	void	pupmode
+void	winconstraints
+void	pagecolor 	short s
+void	textcolor 	short s
+void 	color 	  	short s
+void	curveit		short s
+void	font		short s
+void 	linewidth	short s
+void    setlinestyle	short s
+void	setmap		short s
+void	swapinterval	short s
+void	writemask	short s
+if !solaris	void	textwritemask	short s
+void	qdevice		short s
+void	unqdevice	short s
+void	curvebasis	short s
+void	curveprecision	short s
+void	loadname	short s
+void	passthrough	short s
+void	pushname	short s
+void	setmonitor	short s
+if !solaris	void	setshade	short s
+void	setpattern	short s
+if !solaris	void	pagewritemask	short s
+#
+void	callobj		long s
+void	delobj		long s
+void 	editobj		long s
+void	makeobj		long s
+void	maketag		long s
+void	chunksize	long s
+void	compactify	long s
+void	deltag		long s
+void	lsrepeat	long s
+void	objinsert	long s
+void 	objreplace	long s
+void	winclose	long s
+void	blanktime	long s
+void 	freepup		long s
+# This is not in the library!?
+###void	pupcolor	long s
+#
+void	backbuffer	long s
+void 	frontbuffer	long s
+if !solaris	void	lsbackup	long s
+void	resetls		long s
+void	lampon		long s
+void	lampoff		long s
+void	setbell		long s
+void	blankscreen	long s
+void 	depthcue	long s
+void	zbuffer		long s
+void	backface	long s
+#
+void 	cmov2i		long s long s
+void 	draw2i		long s long s
+void	move2i		long s long s
+void	pnt2i		long s long s
+void 	patchbasis	long s long s
+void 	patchprecision	long s long s
+void	pdr2i		long s long s
+void	pmv2i		long s long s
+void	rpdr2i		long s long s
+void	rpmv2i		long s long s
+void	xfpt2i		long s long s
+void	objdelete	long s long s
+void	patchcurves	long s long s
+void	minsize		long s long s
+void 	maxsize		long s long s
+void	keepaspect	long s long s
+void	prefsize	long s long s
+void	stepunit	long s long s
+void 	fudge		long s long s
+void 	winmove		long s long s
+#
+void 	attachcursor	short s short s
+void 	deflinestyle	short s short s
+void 	noise		short s short s
+void 	picksize	short s short s
+void 	qenter		short s short s
+void 	setdepth	short s short s
+void 	cmov2s		short s short s
+void 	draw2s		short s	short s
+void 	move2s		short s short s
+void 	pdr2s		short s short s
+void 	pmv2s		short s short s
+void 	pnt2s		short s short s
+void 	rdr2s		short s short s
+void 	rmv2s		short s short s
+void 	rpdr2s		short s short s
+void 	rpmv2s		short s short s
+void 	xfpt2s		short s short s
+#
+void cmov2		float s float s
+void draw2		float s float s
+void move2		float s float s
+void pnt2		float s float s
+void pdr2		float s float s
+void pmv2		float s float s
+void rdr2		float s float s
+void rmv2		float s float s
+void rpdr2		float s float s
+void rpmv2		float s float s
+void xfpt2		float s float s
+#
+void loadmatrix		float s[4*4]
+# Really [4][4]
+void multmatrix		float s[4*4]
+# Really [4][4]
+void crv			float s[3*4]
+# Really [4][3]
+void rcrv			float s[4*4]
+# Really [4][4]
+#
+# Methods that have strings.  
+#
+void addtopup		long s char *s long s
+void charstr		char *s
+void getport	 	char *s
+long strwidth		char *s
+long winopen		char *s
+void wintitle		char *s
+#
+# Methods that have 1 long (# of elements) and an array 
+#
+void polf		long s float s[3*arg1]
+void polf2		long s float s[2*arg1]
+void poly		long s float s[3*arg1]
+void poly2		long s float s[2*arg1]
+void crvn		long s float s[3*arg1]
+void rcrvn		long s float s[4*arg1]
+#
+void polf2i		long s long s[2*arg1]
+void polfi		long s long s[3*arg1]
+void poly2i		long s long s[2*arg1]
+void polyi		long s long s[3*arg1]
+#
+void polf2s		long s short s[2*arg1]
+void polfs		long s short s[3*arg1]
+void polys		long s short s[3*arg1]
+void poly2s		long s short s[2*arg1]
+#
+void defcursor		short s u_short s[128]
+# Is this useful?
+void writepixels	short s u_short s[arg1]
+# Should be unsigned short...
+void defbasis		long s float s[4*4]
+if !solaris	void gewrite		short s short s[arg1]
+#
+void rotate		short s char s
+# This is not in the library!?
+###void setbutton		short s char s
+void rot		float s char s
+#
+void circfi		long s long s long s
+void circi		long s long s long s
+void cmovi		long s long s long s
+void drawi		long s long s long s
+void movei		long s long s long s
+void pnti 		long s long s long s
+void newtag		long s long s long s
+void pdri  		long s long s long s
+void pmvi  		long s long s long s
+void rdri  		long s long s long s
+void rmvi  		long s long s long s
+void rpdri 		long s long s long s
+void rpmvi 		long s long s long s
+void xfpti 		long s long s long s
+#
+void circ		float s float s float s
+void circf		float s float s float s
+void cmov		float s float s float s
+void draw		float s float s float s
+void move		float s float s float s
+void pnt		float s float s float s
+void scale		float s float s float s
+void translate		float s float s float s
+void pdr		float s float s float s
+void pmv		float s float s float s
+void rdr		float s float s float s
+void rmv		float s float s float s
+void rpdr		float s float s float s
+void rpmv		float s float s float s
+void xfpt		float s float s float s
+#
+void RGBcolor		short s short s short s
+void RGBwritemask	short s short s short s
+void setcursor		short s short s short s
+void tie		short s short s short s
+void circfs		short s short s short s
+void circs		short s short s short s
+void cmovs		short s short s short s
+void draws		short s short s short s
+void moves		short s short s short s
+void pdrs		short s short s short s
+void pmvs		short s short s short s
+void pnts		short s short s short s
+void rdrs		short s short s short s
+void rmvs		short s short s short s
+void rpdrs		short s short s short s
+void rpmvs		short s short s short s
+void xfpts		short s short s short s
+void curorigin		short s short s short s
+void cyclemap		short s short s short s
+#
+void patch		float s[4*4] float s[4*4] float s[4*4]
+void splf		long s float s[3*arg1] u_short s[arg1]
+void splf2		long s float s[2*arg1] u_short s[arg1]
+void splfi		long s long s[3*arg1] u_short s[arg1]
+void splf2i		long s long s[2*arg1] u_short s[arg1]
+void splfs		long s short s[3*arg1] u_short s[arg1]
+void splf2s		long s short s[2*arg1] u_short s[arg1]
+###void defpattern		short s short s u_short s[arg2*arg2/16]
+#
+void rpatch		float s[4*4] float s[4*4] float s[4*4] float s[4*4]
+#
+# routines that send 4 floats
+#
+void ortho2		float s float s float s float s
+void rect		float s float s float s float s
+void rectf		float s float s float s float s
+void xfpt4		float s float s float s float s
+#
+void textport		short s short s short s short s
+void mapcolor		short s short s short s short s
+void scrmask		short s short s short s short s
+void setvaluator	short s short s short s short s
+void viewport		short s short s short s short s
+void shaderange		short s short s short s short s
+void xfpt4s		short s short s short s short s
+void rectfi		long s long s long s long s
+void recti		long s long s long s long s
+void xfpt4i		long s long s long s long s
+void prefposition	long s long s long s long s
+#
+void arc		float s float s float s short s short s
+void arcf		float s float s float s short s short s
+void arcfi		long s long s long s short s short s
+void arci		long s long s long s short s short s
+#
+void bbox2		short s short s float s float s float s float s
+void bbox2i		short s short s long s long s long s long s
+void bbox2s		short s short s short s short s short s short s
+void blink		short s short s short s short s short s
+void ortho		float s float s float s float s float s float s
+void window		float s float s float s float s float s float s
+void lookat		float s float s float s float s float s float s short s
+#
+void perspective	short s float s float s float s
+void polarview		float s short s short s short s
+# XXX getichararray not supported
+#void writeRGB		short s char s[arg1] char s[arg1] char s[arg1]
+#
+void arcfs		short s short s short s short s short s
+void arcs		short s short s short s short s short s
+void rectcopy		short s short s short s short s short s short s
+if !solaris	void RGBcursor		short s short s short s short s short s short s short s
+#
+long getbutton		short s
+long getcmmode
+long getlsbackup
+long getresetls
+long getdcm
+long getzbuffer
+long ismex
+long isobj		long s
+long isqueued		short s
+long istag		long s
+#
+long genobj
+long gentag
+long getbuffer
+long getcolor
+long getdisplaymode
+long getfont
+long getheight
+long gethitcode
+long getlstyle
+long getlwidth
+long getmap
+long getplanes
+long getwritemask
+long qtest
+long getlsrepeat
+long getmonitor
+long getopenobj
+long getpattern
+long winget
+long winattach
+long getothermonitor
+long newpup
+#
+long getvaluator	short s
+void winset		long s
+long dopup		long s
+void getdepth		short r short r
+void getcpos		short r short r
+void getsize		long r long r
+void getorigin		long r long r
+void getviewport	short r short r short r short r
+if !solaris	void gettp		short r short r short r short r
+void getgpos		float r float r float r float r
+void winposition	long s long s long s long s
+void gRGBcolor		short r short r short r
+void gRGBmask		short r short r short r
+void getscrmask	short r short r short r short r
+###void gRGBcursor	short r short r short r short r short r short r short r short r
+void getmcolor		short s short r short r short r
+void mapw		long s short s short s float r float r float r float r float r float r
+void mapw2		long s short s short s float r float r
+###void defrasterfont	short s short s short s Fontchar s[arg3] short s short s[4*arg5]
+###long qread		short r
+void getcursor		short r u_short r u_short r long r
+#
+#   For these we receive arrays of stuff
+#
+###void getdev 		long s short s[arg1] short r[arg1]
+#XXX not generated correctly yet
+#void getmatrix		float r[16]
+###long readpixels		short s short r[retval]
+###long readRGB		short s char r[retval] char r[retval] char r[retval]
+###long blkqread		short s short r[arg1]
+#
+#   New 4D routines
+#
+void cmode
+void concave		long s
+void curstype		long s
+void drawmode		long s
+void gammaramp		short s[256] short s[256] short s[256]
+long getbackface
+long getdescender
+long getdrawmode
+long getmmode
+long getsm
+long getvideo		long s
+void imakebackground
+void lmbind		short s short s
+void lmdef		long s long s long s float s[arg3]
+void mmode		long s
+void normal		float s[3]
+void overlay		long s
+void RGBrange		short s short s short s short s short s short s short s short s
+if !solaris	void setvideo 		long s long s
+void shademodel		long s
+void underlay		long s
+#
+# New Personal Iris/GT Routines
+#
+void bgnclosedline
+void bgnline
+void bgnpoint
+void bgnpolygon
+void bgnsurface
+void bgntmesh
+void bgntrim
+void endclosedline
+void endline
+void endpoint
+void endpolygon
+void endsurface
+void endtmesh
+void endtrim
+void blendfunction	long s long s
+void c3f		float s[3]
+void c3i		long  s[3]
+void c3s		short s[3]
+void c4f		float s[4]
+void c4i		long  s[4]
+void c4s		short s[4]
+void colorf		float s
+void cpack		long s
+void czclear		long s long s
+void dglclose		long s
+long dglopen		char *s long s
+long getgdesc		long s
+void getnurbsproperty	long s float r
+void glcompat		long s long s
+void iconsize 		long s long s
+void icontitle		char *s
+void lRGBrange		short s short s short s short s short s short s long s long s
+void linesmooth		long s
+void lmcolor		long s
+void logicop		long s
+###long lrectread	 	short s short s short s short s long r[retval]
+###void lrectwrite		short s short s short s short s long s[(arg2-arg1+1)*(arg4-arg3+1)]
+### Now manual, with string last arg
+###long rectread	 	short s short s short s short s short r[retval]
+###void rectwrite		short s short s short s short s short s[(arg2-arg1+1)*(arg4-arg3+1)]
+void lsetdepth		long s long s
+void lshaderange	short s short s long s long s
+void n3f		float s[3]
+void noborder
+void pntsmooth		long s
+void readsource		long s
+void rectzoom		float s float s
+void sbox		float s float s float s float s
+void sboxi		long s long s long s long s
+void sboxs		short s short s short s short s
+void sboxf		float s float s float s float s
+void sboxfi		long s long s long s long s
+void sboxfs		short s short s short s short s
+void setnurbsproperty	long s float s
+void setpup 		long s long s long s
+void smoothline		long s
+void subpixel		long s
+void swaptmesh
+long swinopen		long s
+void v2f		float s[2]
+void v2i		long  s[2]
+void v2s		short s[2]
+void v3f		float s[3]
+void v3i		long  s[3]
+void v3s		short s[3]
+void v4f		float s[4]
+void v4i		long  s[4]
+void v4s		short s[4]
+void videocmd		long s
+long windepth		long s
+void wmpack		long s
+void zdraw		long s
+void zfunction		long s
+void zsource		long s
+void zwritemask		long s
+#
+#   uses doubles
+#
+void v2d		double s[2]
+void v3d		double s[3]
+void v4d		double s[4]
+#
+# Why isn't this here?
+#
+void pixmode		long s long s
+#
+# New in IRIX 4.0
+#
+long qgetfd
+void dither		long s