--- /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