Modules/glmodule.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /*
  33 Input used to generate the Python module "glmodule.c".
  34 The stub generator is a Python script called "cgen.py".
  35
  36 Each definition must be contained on one line:
  37
  38 <returntype> <name> <type> <arg> <type> <arg>
  39
  40 <returntype> can be: void, short, long (XXX maybe others?)
  41
  42 <type> can be: char, string, short, float, long, or double
  43         string indicates a null terminated string;
  44         if <type> is char and <arg> begins with a *, the * is stripped
  45         and <type> is changed into string
  46
  47 <arg> has the form <mode> or <mode>[<subscript>]
  48         where <mode> can be
  49                 s: arg is sent
  50                 r: arg is received              (arg is a pointer)
  51         and <subscript> can be (N and I are numbers):
  52                 N
  53                 argI
  54                 retval
  55                 N*argI
  56                 N*I
  57                 N*retval
  58         In the case where the subscript consists of two parts
  59         separated by *, the first part is the width of the matrix, and
  60         the second part is the length of the matrix.  This order is
  61         opposite from the order used in C to declare a two-dimensional
  62         matrix.
  63 */
  64
  65 /*
  66  * An attempt has been made to make this module switch threads on qread
  67  * calls. It is far from safe, though.
  68  */
  69
  70 #include <gl.h>
  71 #include <device.h>
  72
  73 #ifdef __sgi
  74 extern int devport();
  75 extern int textwritemask();
  76 extern int pagewritemask();
  77 extern int gewrite();
  78 extern int gettp();
  79 #endif
  80
  81 #include "Python.h"
  82 #include "cgensupport.h"
  83
  84 /*
  85 Some stubs are too complicated for the stub generator.
  86 We can include manually written versions of them here.
  87 A line starting with '%' gives the name of the function so the stub
  88 generator can include it in the table of functions.
  89 */
  90
  91
  92 static PyObject *
  93 gl_qread(self, args)
  94         PyObject *self;
  95         PyObject *args;
  96 {
  97         long retval;
  98         short arg1 ;
  99         Py_BEGIN_ALLOW_THREADS
 100         retval = qread( & arg1 );
 101         Py_END_ALLOW_THREADS
 102         { PyObject *v = PyTuple_New( 2 );
 103           if (v == NULL) return NULL;
 104           PyTuple_SetItem(v, 0, mknewlongobject(retval));
 105           PyTuple_SetItem(v, 1, mknewshortobject(arg1));
 106           return v;
 107         }
 108 }
 109
 110
 111 /*
 112 varray -- an array of v.. calls.
 113 The argument is an array (maybe list or tuple) of points.
 114 Each point must be a tuple or list of coordinates (x, y, z).
 115 The points may be 2- or 3-dimensional but must all have the
 116 same dimension.  Float and int values may be mixed however.
 117 The points are always converted to 3D double precision points
 118 by assuming z=0.0 if necessary (as indicated in the man page),
 119 and for each point v3d() is called.
 120 */
 121
 122
 123 static PyObject *
 124 gl_varray(self, args)
 125         PyObject *self;
 126         PyObject *args;
 127 {
 128         PyObject *v, *w=NULL;
 129         int i, n, width;
 130         double vec[3];
 131         PyObject * (*getitem) Py_FPROTO((PyObject *, int));
 132
 133         if (!PyArg_GetObject(args, 1, 0, &v))
 134                 return NULL;
 135
 136         if (PyList_Check(v)) {
 137                 n = PyList_Size(v);
 138                 getitem = PyList_GetItem;
 139         }
 140         else if (PyTuple_Check(v)) {
 141                 n = PyTuple_Size(v);
 142                 getitem = PyTuple_GetItem;
 143         }
 144         else {
 145                 PyErr_BadArgument();
 146                 return NULL;
 147         }
 148
 149         if (n == 0) {
 150                 Py_INCREF(Py_None);
 151                 return Py_None;
 152         }
 153         if (n > 0)
 154                 w = (*getitem)(v, 0);
 155
 156         width = 0;
 157         if (w == NULL) {
 158         }
 159         else if (PyList_Check(w)) {
 160                 width = PyList_Size(w);
 161         }
 162         else if (PyTuple_Check(w)) {
 163                 width = PyTuple_Size(w);
 164         }
 165
 166         switch (width) {
 167         case 2:
 168                 vec[2] = 0.0;
 169                 /* Fall through */
 170         case 3:
 171                 break;
 172         default:
 173                 PyErr_BadArgument();
 174                 return NULL;
 175         }
 176
 177         for (i = 0; i < n; i++) {
 178                 w = (*getitem)(v, i);
 179                 if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
 180                         return NULL;
 181                 v3d(vec);
 182         }
 183
 184         Py_INCREF(Py_None);
 185         return Py_None;
 186 }
 187
 188 /*
 189 vnarray, nvarray -- an array of n3f and v3f calls.
 190 The argument is an array (list or tuple) of pairs of points and normals.
 191 Each pair is a tuple (NOT a list) of a point and a normal for that point.
 192 Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
 193 Three coordinates must be given.  Float and int values may be mixed.
 194 For each pair, n3f() is called for the normal, and then v3f() is called
 195 for the vector.
 196
 197 vnarray and nvarray differ only in the order of the vector and normal in
 198 the pair: vnarray expects (v, n) while nvarray expects (n, v).
 199 */
 200
 201 static PyObject *gen_nvarray(); /* Forward */
 202
 203
 204 static PyObject *
 205 gl_nvarray(self, args)
 206         PyObject *self;
 207         PyObject *args;
 208 {
 209         return gen_nvarray(args, 0);
 210 }
 211
 212
 213 static PyObject *
 214 gl_vnarray(self, args)
 215         PyObject *self;
 216         PyObject *args;
 217 {
 218         return gen_nvarray(args, 1);
 219 }
 220
 221 /* Generic, internal version of {nv,nv}array: inorm indicates the
 222    argument order, 0: normal first, 1: vector first. */
 223
 224 static PyObject *
 225 gen_nvarray(args, inorm)
 226         PyObject *args;
 227         int inorm;
 228 {
 229         PyObject *v, *w, *wnorm, *wvec;
 230         int i, n;
 231         float norm[3], vec[3];
 232         PyObject * (*getitem) Py_FPROTO((PyObject *, int));
 233
 234         if (!PyArg_GetObject(args, 1, 0, &v))
 235                 return NULL;
 236
 237         if (PyList_Check(v)) {
 238                 n = PyList_Size(v);
 239                 getitem = PyList_GetItem;
 240         }
 241         else if (PyTuple_Check(v)) {
 242                 n = PyTuple_Size(v);
 243                 getitem = PyTuple_GetItem;
 244         }
 245         else {
 246                 PyErr_BadArgument();
 247                 return NULL;
 248         }
 249
 250         for (i = 0; i < n; i++) {
 251                 w = (*getitem)(v, i);
 252                 if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {
 253                         PyErr_BadArgument();
 254                         return NULL;
 255                 }
 256                 wnorm = PyTuple_GetItem(w, inorm);
 257                 wvec = PyTuple_GetItem(w, 1 - inorm);
 258                 if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
 259                         !PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
 260                         return NULL;
 261                 n3f(norm);
 262                 v3f(vec);
 263         }
 264
 265         Py_INCREF(Py_None);
 266         return Py_None;
 267 }
 268
 269 /* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
 270    The dimensions of ctl[] are computed as follows:
 271    [len(s_knots) - s_order], [len(t_knots) - t_order]
 272 */
 273
 274
 275 static PyObject *
 276 gl_nurbssurface(self, args)
 277         PyObject *self;
 278         PyObject *args;
 279 {
 280         long arg1 ;
 281         double * arg2 ;
 282         long arg3 ;
 283         double * arg4 ;
 284         double *arg5 ;
 285         long arg6 ;
 286         long arg7 ;
 287         long arg8 ;
 288         long ncoords;
 289         long s_byte_stride, t_byte_stride;
 290         long s_nctl, t_nctl;
 291         long s, t;
 292         PyObject *v, *w, *pt;
 293         double *pnext;
 294         if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
 295                 return NULL;
 296         if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
 297                 return PyErr_NoMemory();
 298         }
 299         if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
 300                 return NULL;
 301         if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
 302                 return NULL;
 303         if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {
 304                 return PyErr_NoMemory();
 305         }
 306         if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
 307                 return NULL;
 308         if (!PyArg_GetLong(args, 6, 3, &arg6))
 309                 return NULL;
 310         if (!PyArg_GetLong(args, 6, 4, &arg7))
 311                 return NULL;
 312         if (!PyArg_GetLong(args, 6, 5, &arg8))
 313                 return NULL;
 314         if (arg8 == N_XYZ)
 315                 ncoords = 3;
 316         else if (arg8 == N_XYZW)
 317                 ncoords = 4;
 318         else {
 319                 PyErr_BadArgument();
 320                 return NULL;
 321         }
 322         s_nctl = arg1 - arg6;
 323         t_nctl = arg3 - arg7;
 324         if (!PyArg_GetObject(args, 6, 2, &v))
 325                 return NULL;
 326         if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {
 327                 PyErr_BadArgument();
 328                 return NULL;
 329         }
 330         if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
 331                 return PyErr_NoMemory();
 332         }
 333         pnext = arg5;
 334         for (s = 0; s < s_nctl; s++) {
 335                 w = PyList_GetItem(v, s);
 336                 if (w == NULL || !PyList_Check(w) ||
 337                                         PyList_Size(w) != t_nctl) {
 338                         PyErr_BadArgument();
 339                         return NULL;
 340                 }
 341                 for (t = 0; t < t_nctl; t++) {
 342                         pt = PyList_GetItem(w, t);
 343                         if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
 344                                 return NULL;
 345                         pnext += ncoords;
 346                 }
 347         }
 348         s_byte_stride = sizeof(double) * ncoords;
 349         t_byte_stride = s_byte_stride * s_nctl;
 350         nurbssurface( arg1 , arg2 , arg3 , arg4 ,
 351                 s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
 352         PyMem_DEL(arg2);
 353         PyMem_DEL(arg4);
 354         PyMem_DEL(arg5);
 355         Py_INCREF(Py_None);
 356         return Py_None;
 357 }
 358
 359 /* nurbscurve(knots, ctlpoints, order, type).
 360    The length of ctlpoints is len(knots)-order. */
 361
 362
 363 static PyObject *
 364 gl_nurbscurve(self, args)
 365         PyObject *self;
 366         PyObject *args;
 367 {
 368         long arg1 ;
 369         double * arg2 ;
 370         long arg3 ;
 371         double * arg4 ;
 372         long arg5 ;
 373         long arg6 ;
 374         int ncoords, npoints;
 375         int i;
 376         PyObject *v;
 377         double *pnext;
 378         if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
 379                 return NULL;
 380         if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
 381                 return PyErr_NoMemory();
 382         }
 383         if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
 384                 return NULL;
 385         if (!PyArg_GetLong(args, 4, 2, &arg5))
 386                 return NULL;
 387         if (!PyArg_GetLong(args, 4, 3, &arg6))
 388                 return NULL;
 389         if (arg6 == N_ST)
 390                 ncoords = 2;
 391         else if (arg6 == N_STW)
 392                 ncoords = 3;
 393         else {
 394                 PyErr_BadArgument();
 395                 return NULL;
 396         }
 397         npoints = arg1 - arg5;
 398         if (!PyArg_GetObject(args, 4, 1, &v))
 399                 return NULL;
 400         if (!PyList_Check(v) || PyList_Size(v) != npoints) {
 401                 PyErr_BadArgument();
 402                 return NULL;
 403         }
 404         if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {
 405                 return PyErr_NoMemory();
 406         }
 407         pnext = arg4;
 408         for (i = 0; i < npoints; i++) {
 409                 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
 410                         return NULL;
 411                 pnext += ncoords;
 412         }
 413         arg3 = (sizeof(double)) * ncoords;
 414         nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
 415         PyMem_DEL(arg2);
 416         PyMem_DEL(arg4);
 417         Py_INCREF(Py_None);
 418         return Py_None;
 419 }
 420
 421 /* pwlcurve(points, type).
 422    Points is a list of points. Type must be N_ST. */
 423
 424
 425 static PyObject *
 426 gl_pwlcurve(self, args)
 427         PyObject *self;
 428         PyObject *args;
 429 {
 430         PyObject *v;
 431         long type;
 432         double *data, *pnext;
 433         long npoints, ncoords;
 434         int i;
 435         if (!PyArg_GetObject(args, 2, 0, &v))
 436                 return NULL;
 437         if (!PyArg_GetLong(args, 2, 1, &type))
 438                 return NULL;
 439         if (!PyList_Check(v)) {
 440                 PyErr_BadArgument();
 441                 return NULL;
 442         }
 443         npoints = PyList_Size(v);
 444         if (type == N_ST)
 445                 ncoords = 2;
 446         else {
 447                 PyErr_BadArgument();
 448                 return NULL;
 449         }
 450         if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {
 451                 return PyErr_NoMemory();
 452         }
 453         pnext = data;
 454         for (i = 0; i < npoints; i++) {
 455                 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
 456                         return NULL;
 457                 pnext += ncoords;
 458         }
 459         pwlcurve(npoints, data, sizeof(double)*ncoords, type);
 460         PyMem_DEL(data);
 461         Py_INCREF(Py_None);
 462         return Py_None;
 463 }
 464
 465
 466 /* Picking and Selecting */
 467
 468 static short *pickbuffer = NULL;
 469 static long pickbuffersize;
 470
 471 static PyObject *
 472 pick_select(args, func)
 473         PyObject *args;
 474         void (*func)();
 475 {
 476         if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
 477                 return NULL;
 478         if (pickbuffer != NULL) {
 479                 PyErr_SetString(PyExc_RuntimeError,
 480                         "pick/gselect: already picking/selecting");
 481                 return NULL;
 482         }
 483         if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {
 484                 return PyErr_NoMemory();
 485         }
 486         (*func)(pickbuffer, pickbuffersize);
 487         Py_INCREF(Py_None);
 488         return Py_None;
 489 }
 490
 491 static PyObject *
 492 endpick_select(args, func)
 493         PyObject *args;
 494         long (*func)();
 495 {
 496         PyObject *v, *w;
 497         int i, nhits, n;
 498         if (!PyArg_NoArgs(args))
 499                 return NULL;
 500         if (pickbuffer == NULL) {
 501                 PyErr_SetString(PyExc_RuntimeError,
 502                         "endpick/endselect: not in pick/select mode");
 503                 return NULL;
 504         }
 505         nhits = (*func)(pickbuffer);
 506         if (nhits < 0) {
 507                 nhits = -nhits; /* How to report buffer overflow otherwise? */
 508         }
 509         /* Scan the buffer to see how many integers */
 510         n = 0;
 511         for (; nhits > 0; nhits--) {
 512                 n += 1 + pickbuffer[n];
 513         }
 514         v = PyList_New(n);
 515         if (v == NULL)
 516                 return NULL;
 517         /* XXX Could do it nicer and interpret the data structure here,
 518            returning a list of lists. But this can be done in Python... */
 519         for (i = 0; i < n; i++) {
 520                 w = PyInt_FromLong((long)pickbuffer[i]);
 521                 if (w == NULL) {
 522                         Py_DECREF(v);
 523                         return NULL;
 524                 }
 525                 PyList_SetItem(v, i, w);
 526         }
 527         PyMem_DEL(pickbuffer);
 528         pickbuffer = NULL;
 529         return v;
 530 }
 531
 532 extern void pick(), gselect();
 533 extern long endpick(), endselect();
 534
 535 static PyObject *gl_pick(self, args) PyObject *self, *args; {
 536         return pick_select(args, pick);
 537 }
 538
 539 static PyObject *gl_endpick(self, args) PyObject *self, *args; {
 540         return endpick_select(args, endpick);
 541 }
 542
 543 static PyObject *gl_gselect(self, args) PyObject *self, *args; {
 544         return pick_select(args, gselect);
 545 }
 546
 547 static PyObject *gl_endselect(self, args) PyObject *self, *args; {
 548         return endpick_select(args, endselect);
 549 }
 550
 551
 552 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 553
 554 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 555
 556
 557 static PyObject *
 558 gl_getmatrix(self, args)
 559         PyObject *self;
 560         PyObject *args;
 561 {
 562         Matrix arg1;
 563         PyObject *v, *w;
 564         int i, j;
 565         getmatrix( arg1 );
 566         v = PyList_New(16);
 567         if (v == NULL) {
 568                 return PyErr_NoMemory();
 569         }
 570         for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
 571                 w = mknewfloatobject(arg1[i][j]);
 572                 if (w == NULL) {
 573                         Py_DECREF(v);
 574                         return NULL;
 575                 }
 576                 PyList_SetItem(v, i*4+j, w);
 577         }
 578         return v;
 579 }
 580
 581 /* Here's an alternate version that returns a 4x4 matrix instead of
 582    a vector.  Unfortunately it is incompatible with loadmatrix and
 583    multmatrix... */
 584
 585
 586 static PyObject *
 587 gl_altgetmatrix(self, args)
 588         PyObject *self;
 589         PyObject *args;
 590 {
 591         Matrix arg1;
 592         PyObject *v, *w;
 593         int i, j;
 594         getmatrix( arg1 );
 595         v = PyList_New(4);
 596         if (v == NULL) {
 597                 return NULL;
 598         }
 599         for (i = 0; i < 4; i++) {
 600                 w = PyList_New(4);
 601                 if (w == NULL) {
 602                         Py_DECREF(v);
 603                         return NULL;
 604                 }
 605                 PyList_SetItem(v, i, w);
 606         }
 607         for (i = 0; i < 4; i++) {
 608                 for (j = 0; j < 4; j++) {
 609                         w = mknewfloatobject(arg1[i][j]);
 610                         if (w == NULL) {
 611                                 Py_DECREF(v);
 612                                 return NULL;
 613                         }
 614                         PyList_SetItem(PyList_GetItem(v, i), j, w);
 615                 }
 616         }
 617         return v;
 618 }
 619
 620
 621 static PyObject *
 622 gl_lrectwrite(self, args)
 623         PyObject *self;
 624         PyObject *args;
 625 {
 626         short x1 ;
 627         short y1 ;
 628         short x2 ;
 629         short y2 ;
 630         string parray ;
 631         PyObject *s;
 632 #if 0
 633         int pixcount;
 634 #endif
 635         if (!PyArg_GetShort(args, 5, 0, &x1))
 636                 return NULL;
 637         if (!PyArg_GetShort(args, 5, 1, &y1))
 638                 return NULL;
 639         if (!PyArg_GetShort(args, 5, 2, &x2))
 640                 return NULL;
 641         if (!PyArg_GetShort(args, 5, 3, &y2))
 642                 return NULL;
 643         if (!PyArg_GetString(args, 5, 4, &parray))
 644                 return NULL;
 645         if (!PyArg_GetObject(args, 5, 4, &s))
 646                 return NULL;
 647 #if 0
 648 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
 649         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 650         if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
 651                 PyErr_SetString(PyExc_RuntimeError,
 652                            "string arg to lrectwrite has wrong size");
 653                 return NULL;
 654         }
 655 #endif
 656         lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
 657         Py_INCREF(Py_None);
 658         return Py_None;
 659 }
 660
 661
 662 static PyObject *
 663 gl_lrectread(self, args)
 664         PyObject *self;
 665         PyObject *args;
 666 {
 667         short x1 ;
 668         short y1 ;
 669         short x2 ;
 670         short y2 ;
 671         PyObject *parray;
 672         int pixcount;
 673         if (!PyArg_GetShort(args, 4, 0, &x1))
 674                 return NULL;
 675         if (!PyArg_GetShort(args, 4, 1, &y1))
 676                 return NULL;
 677         if (!PyArg_GetShort(args, 4, 2, &x2))
 678                 return NULL;
 679         if (!PyArg_GetShort(args, 4, 3, &y2))
 680                 return NULL;
 681         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 682         parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 683         if (parray == NULL)
 684                 return NULL; /* No memory */
 685         lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
 686         return parray;
 687 }
 688
 689
 690 static PyObject *
 691 gl_readdisplay(self, args)
 692         PyObject *self;
 693         PyObject *args;
 694 {
 695         short x1, y1, x2, y2;
 696         unsigned long *parray, hints;
 697         long size, size_ret;
 698         PyObject *rv;
 699
 700         if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
 701           return 0;
 702         size = (long)(x2+1-x1) * (long)(y2+1-y1);
 703         rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
 704         if ( rv == NULL )
 705           return NULL;
 706         parray = (unsigned long *)PyString_AsString(rv);
 707         size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
 708         if ( size_ret != size ) {
 709             printf("gl_readdisplay: got %ld pixels, expected %ld\n",
 710                    size_ret, size);
 711             PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");
 712             return NULL;
 713         }
 714         return rv;
 715 }
 716
 717 /* Desperately needed, here are tools to compress and decompress
 718    the data manipulated by lrectread/lrectwrite.
 719
 720    gl.packrect(width, height, packfactor, bigdata) --> smalldata
 721                 makes 'bigdata' 4*(packfactor**2) times smaller by:
 722                 - turning it into B/W (a factor 4)
 723                 - replacing squares of size pacfactor by one
 724                   representative
 725
 726    gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
 727                 is the inverse; the numeric arguments must be *the same*.
 728
 729    Both work best if width and height are multiples of packfactor
 730    (in fact unpackrect will leave garbage bytes).
 731 */
 732
 733
 734 static PyObject *
 735 gl_packrect(self, args)
 736         PyObject *self;
 737         PyObject *args;
 738 {
 739         long width, height, packfactor;
 740         char *s;
 741         PyObject *unpacked, *packed;
 742         int pixcount, packedcount, x, y, r, g, b;
 743         unsigned long pixel;
 744         unsigned char *p;
 745         unsigned long *parray;
 746         if (!PyArg_GetLong(args, 4, 0, &width))
 747                 return NULL;
 748         if (!PyArg_GetLong(args, 4, 1, &height))
 749                 return NULL;
 750         if (!PyArg_GetLong(args, 4, 2, &packfactor))
 751                 return NULL;
 752         if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
 753                 return NULL;
 754         if (!PyArg_GetObject(args, 4, 3, &unpacked))
 755                 return NULL;
 756         if (width <= 0 || height <= 0 || packfactor <= 0) {
 757                 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
 758                 return NULL;
 759         }
 760         pixcount = width*height;
 761         packedcount = ((width+packfactor-1)/packfactor) *
 762                 ((height+packfactor-1)/packfactor);
 763         if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
 764                 PyErr_SetString(PyExc_RuntimeError,
 765                            "string arg to packrect has wrong size");
 766                 return NULL;
 767         }
 768         packed = PyString_FromStringAndSize((char *)NULL, packedcount);
 769         if (packed == NULL)
 770                 return NULL;
 771         parray = (unsigned long *) PyString_AsString(unpacked);
 772         p = (unsigned char *) PyString_AsString(packed);
 773         for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
 774                 for (x = 0; x < width; x += packfactor) {
 775                         pixel = parray[x];
 776                         r = pixel & 0xff;
 777                         g = (pixel >> 8) & 0xff;
 778                         b = (pixel >> 16) & 0xff;
 779                         *p++ = (30*r+59*g+11*b) / 100;
 780                 }
 781         }
 782         return packed;
 783 }
 784
 785
 786 static unsigned long unpacktab[256];
 787 static int unpacktab_inited = 0;
 788
 789 static PyObject *
 790 gl_unpackrect(self, args)
 791         PyObject *self;
 792         PyObject *args;
 793 {
 794         long width, height, packfactor;
 795         char *s;
 796         PyObject *unpacked, *packed;
 797         int pixcount, packedcount;
 798         register unsigned char *p;
 799         register unsigned long *parray;
 800         if (!unpacktab_inited) {
 801                 register int white;
 802                 for (white = 256; --white >= 0; )
 803                         unpacktab[white] = white * 0x010101L;
 804                 unpacktab_inited++;
 805         }
 806         if (!PyArg_GetLong(args, 4, 0, &width))
 807                 return NULL;
 808         if (!PyArg_GetLong(args, 4, 1, &height))
 809                 return NULL;
 810         if (!PyArg_GetLong(args, 4, 2, &packfactor))
 811                 return NULL;
 812         if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
 813                 return NULL;
 814         if (!PyArg_GetObject(args, 4, 3, &packed))
 815                 return NULL;
 816         if (width <= 0 || height <= 0 || packfactor <= 0) {
 817                 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
 818                 return NULL;
 819         }
 820         pixcount = width*height;
 821         packedcount = ((width+packfactor-1)/packfactor) *
 822                 ((height+packfactor-1)/packfactor);
 823         if (PyString_Size(packed) != packedcount) {
 824                 PyErr_SetString(PyExc_RuntimeError,
 825                            "string arg to unpackrect has wrong size");
 826                 return NULL;
 827         }
 828         unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 829         if (unpacked == NULL)
 830                 return NULL;
 831         parray = (unsigned long *) PyString_AsString(unpacked);
 832         p = (unsigned char *) PyString_AsString(packed);
 833         if (packfactor == 1 && width*height > 0) {
 834                 /* Just expand bytes to longs */
 835                 register int x = width * height;
 836                 do {
 837                         *parray++ = unpacktab[*p++];
 838                 } while (--x >= 0);
 839         }
 840         else {
 841                 register int y;
 842                 for (y = 0; y < height-packfactor+1;
 843                      y += packfactor, parray += packfactor*width) {
 844                         register int x;
 845                         for (x = 0; x < width-packfactor+1; x += packfactor) {
 846                                 register unsigned long pixel = unpacktab[*p++];
 847                                 register int i;
 848                                 for (i = packfactor*width; (i-=width) >= 0;) {
 849                                         register int j;
 850                                         for (j = packfactor; --j >= 0; )
 851                                                 parray[i+x+j] = pixel;
 852                                 }
 853                         }
 854                 }
 855         }
 856         return unpacked;
 857 }
 858
 859 static PyObject *
 860 gl_gversion(self, args)
 861         PyObject *self;
 862         PyObject *args;
 863 {
 864         char buf[20];
 865         gversion(buf);
 866         return PyString_FromString(buf);
 867 }
 868
 869
 870 /* void clear - Manual because of clash with termcap */
 871 static PyObject *
 872 gl_clear(self, args)
 873         PyObject *self;
 874         PyObject *args;
 875 {
 876         __GLclear( );
 877         Py_INCREF(Py_None);
 878         return Py_None;
 879 }
 880
 881 /* End of manually written stubs */
 882
 883
 884 /* long getshade */
 885
 886 static PyObject *
 887 gl_getshade(self, args)
 888         PyObject *self;
 889         PyObject *args;
 890 {
 891         long retval;
 892         retval = getshade( );
 893         return mknewlongobject(retval);
 894 }
 895
 896 /* void devport short s long s */
 897
 898 static PyObject *
 899 gl_devport(self, args)
 900         PyObject *self;
 901         PyObject *args;
 902 {
 903         short arg1 ;
 904         long arg2 ;
 905         if (!getishortarg(args, 2, 0, &arg1))
 906                 return NULL;
 907         if (!getilongarg(args, 2, 1, &arg2))
 908                 return NULL;
 909         devport( arg1 , arg2 );
 910         Py_INCREF(Py_None);
 911         return Py_None;
 912 }
 913
 914 /* void rdr2i long s long s */
 915
 916 static PyObject *
 917 gl_rdr2i(self, args)
 918         PyObject *self;
 919         PyObject *args;
 920 {
 921         long arg1 ;
 922         long arg2 ;
 923         if (!getilongarg(args, 2, 0, &arg1))
 924                 return NULL;
 925         if (!getilongarg(args, 2, 1, &arg2))
 926                 return NULL;
 927         rdr2i( arg1 , arg2 );
 928         Py_INCREF(Py_None);
 929         return Py_None;
 930 }
 931
 932 /* void rectfs short s short s short s short s */
 933
 934 static PyObject *
 935 gl_rectfs(self, args)
 936         PyObject *self;
 937         PyObject *args;
 938 {
 939         short arg1 ;
 940         short arg2 ;
 941         short arg3 ;
 942         short arg4 ;
 943         if (!getishortarg(args, 4, 0, &arg1))
 944                 return NULL;
 945         if (!getishortarg(args, 4, 1, &arg2))
 946                 return NULL;
 947         if (!getishortarg(args, 4, 2, &arg3))
 948                 return NULL;
 949         if (!getishortarg(args, 4, 3, &arg4))
 950                 return NULL;
 951         rectfs( arg1 , arg2 , arg3 , arg4 );
 952         Py_INCREF(Py_None);
 953         return Py_None;
 954 }
 955
 956 /* void rects short s short s short s short s */
 957
 958 static PyObject *
 959 gl_rects(self, args)
 960         PyObject *self;
 961         PyObject *args;
 962 {
 963         short arg1 ;
 964         short arg2 ;
 965         short arg3 ;
 966         short arg4 ;
 967         if (!getishortarg(args, 4, 0, &arg1))
 968                 return NULL;
 969         if (!getishortarg(args, 4, 1, &arg2))
 970                 return NULL;
 971         if (!getishortarg(args, 4, 2, &arg3))
 972                 return NULL;
 973         if (!getishortarg(args, 4, 3, &arg4))
 974                 return NULL;
 975         rects( arg1 , arg2 , arg3 , arg4 );
 976         Py_INCREF(Py_None);
 977         return Py_None;
 978 }
 979
 980 /* void rmv2i long s long s */
 981
 982 static PyObject *
 983 gl_rmv2i(self, args)
 984         PyObject *self;
 985         PyObject *args;
 986 {
 987         long arg1 ;
 988         long arg2 ;
 989         if (!getilongarg(args, 2, 0, &arg1))
 990                 return NULL;
 991         if (!getilongarg(args, 2, 1, &arg2))
 992                 return NULL;
 993         rmv2i( arg1 , arg2 );
 994         Py_INCREF(Py_None);
 995         return Py_None;
 996 }
 997
 998 /* void noport */
 999
1000 static PyObject *
1001 gl_noport(self, args)
1002         PyObject *self;
1003         PyObject *args;
1004 {
1005         noport( );
1006         Py_INCREF(Py_None);
1007         return Py_None;
1008 }
1009
1010 /* void popviewport */
1011
1012 static PyObject *
1013 gl_popviewport(self, args)
1014         PyObject *self;
1015         PyObject *args;
1016 {
1017         popviewport( );
1018         Py_INCREF(Py_None);
1019         return Py_None;
1020 }
1021
1022 /* void clearhitcode */
1023
1024 static PyObject *
1025 gl_clearhitcode(self, args)
1026         PyObject *self;
1027         PyObject *args;
1028 {
1029         clearhitcode( );
1030         Py_INCREF(Py_None);
1031         return Py_None;
1032 }
1033
1034 /* void closeobj */
1035
1036 static PyObject *
1037 gl_closeobj(self, args)
1038         PyObject *self;
1039         PyObject *args;
1040 {
1041         closeobj( );
1042         Py_INCREF(Py_None);
1043         return Py_None;
1044 }
1045
1046 /* void cursoff */
1047
1048 static PyObject *
1049 gl_cursoff(self, args)
1050         PyObject *self;
1051         PyObject *args;
1052 {
1053         cursoff( );
1054         Py_INCREF(Py_None);
1055         return Py_None;
1056 }
1057
1058 /* void curson */
1059
1060 static PyObject *
1061 gl_curson(self, args)
1062         PyObject *self;
1063         PyObject *args;
1064 {
1065         curson( );
1066         Py_INCREF(Py_None);
1067         return Py_None;
1068 }
1069
1070 /* void doublebuffer */
1071
1072 static PyObject *
1073 gl_doublebuffer(self, args)
1074         PyObject *self;
1075         PyObject *args;
1076 {
1077         doublebuffer( );
1078         Py_INCREF(Py_None);
1079         return Py_None;
1080 }
1081
1082 /* void finish */
1083
1084 static PyObject *
1085 gl_finish(self, args)
1086         PyObject *self;
1087         PyObject *args;
1088 {
1089         finish( );
1090         Py_INCREF(Py_None);
1091         return Py_None;
1092 }
1093
1094 /* void gconfig */
1095
1096 static PyObject *
1097 gl_gconfig(self, args)
1098         PyObject *self;
1099         PyObject *args;
1100 {
1101         gconfig( );
1102         Py_INCREF(Py_None);
1103         return Py_None;
1104 }
1105
1106 /* void ginit */
1107
1108 static PyObject *
1109 gl_ginit(self, args)
1110         PyObject *self;
1111         PyObject *args;
1112 {
1113         ginit( );
1114         Py_INCREF(Py_None);
1115         return Py_None;
1116 }
1117
1118 /* void greset */
1119
1120 static PyObject *
1121 gl_greset(self, args)
1122         PyObject *self;
1123         PyObject *args;
1124 {
1125         greset( );
1126         Py_INCREF(Py_None);
1127         return Py_None;
1128 }
1129
1130 /* void multimap */
1131
1132 static PyObject *
1133 gl_multimap(self, args)
1134         PyObject *self;
1135         PyObject *args;
1136 {
1137         multimap( );
1138         Py_INCREF(Py_None);
1139         return Py_None;
1140 }
1141
1142 /* void onemap */
1143
1144 static PyObject *
1145 gl_onemap(self, args)
1146         PyObject *self;
1147         PyObject *args;
1148 {
1149         onemap( );
1150         Py_INCREF(Py_None);
1151         return Py_None;
1152 }
1153
1154 /* void popattributes */
1155
1156 static PyObject *
1157 gl_popattributes(self, args)
1158         PyObject *self;
1159         PyObject *args;
1160 {
1161         popattributes( );
1162         Py_INCREF(Py_None);
1163         return Py_None;
1164 }
1165
1166 /* void popmatrix */
1167
1168 static PyObject *
1169 gl_popmatrix(self, args)
1170         PyObject *self;
1171         PyObject *args;
1172 {
1173         popmatrix( );
1174         Py_INCREF(Py_None);
1175         return Py_None;
1176 }
1177
1178 /* void pushattributes */
1179
1180 static PyObject *
1181 gl_pushattributes(self, args)
1182         PyObject *self;
1183         PyObject *args;
1184 {
1185         pushattributes( );
1186         Py_INCREF(Py_None);
1187         return Py_None;
1188 }
1189
1190 /* void pushmatrix */
1191
1192 static PyObject *
1193 gl_pushmatrix(self, args)
1194         PyObject *self;
1195         PyObject *args;
1196 {
1197         pushmatrix( );
1198         Py_INCREF(Py_None);
1199         return Py_None;
1200 }
1201
1202 /* void pushviewport */
1203
1204 static PyObject *
1205 gl_pushviewport(self, args)
1206         PyObject *self;
1207         PyObject *args;
1208 {
1209         pushviewport( );
1210         Py_INCREF(Py_None);
1211         return Py_None;
1212 }
1213
1214 /* void qreset */
1215
1216 static PyObject *
1217 gl_qreset(self, args)
1218         PyObject *self;
1219         PyObject *args;
1220 {
1221         qreset( );
1222         Py_INCREF(Py_None);
1223         return Py_None;
1224 }
1225
1226 /* void RGBmode */
1227
1228 static PyObject *
1229 gl_RGBmode(self, args)
1230         PyObject *self;
1231         PyObject *args;
1232 {
1233         RGBmode( );
1234         Py_INCREF(Py_None);
1235         return Py_None;
1236 }
1237
1238 /* void singlebuffer */
1239
1240 static PyObject *
1241 gl_singlebuffer(self, args)
1242         PyObject *self;
1243         PyObject *args;
1244 {
1245         singlebuffer( );
1246         Py_INCREF(Py_None);
1247         return Py_None;
1248 }
1249
1250 /* void swapbuffers */
1251
1252 static PyObject *
1253 gl_swapbuffers(self, args)
1254         PyObject *self;
1255         PyObject *args;
1256 {
1257         swapbuffers( );
1258         Py_INCREF(Py_None);
1259         return Py_None;
1260 }
1261
1262 /* void gsync */
1263
1264 static PyObject *
1265 gl_gsync(self, args)
1266         PyObject *self;
1267         PyObject *args;
1268 {
1269         gsync( );
1270         Py_INCREF(Py_None);
1271         return Py_None;
1272 }
1273
1274 /* void gflush */
1275
1276 static PyObject *
1277 gl_gflush(self, args)
1278         PyObject *self;
1279         PyObject *args;
1280 {
1281         gflush( );
1282         Py_INCREF(Py_None);
1283         return Py_None;
1284 }
1285
1286 /* void tpon */
1287
1288 static PyObject *
1289 gl_tpon(self, args)
1290         PyObject *self;
1291         PyObject *args;
1292 {
1293         tpon( );
1294         Py_INCREF(Py_None);
1295         return Py_None;
1296 }
1297
1298 /* void tpoff */
1299
1300 static PyObject *
1301 gl_tpoff(self, args)
1302         PyObject *self;
1303         PyObject *args;
1304 {
1305         tpoff( );
1306         Py_INCREF(Py_None);
1307         return Py_None;
1308 }
1309
1310 /* void clkon */
1311
1312 static PyObject *
1313 gl_clkon(self, args)
1314         PyObject *self;
1315         PyObject *args;
1316 {
1317         clkon( );
1318         Py_INCREF(Py_None);
1319         return Py_None;
1320 }
1321
1322 /* void clkoff */
1323
1324 static PyObject *
1325 gl_clkoff(self, args)
1326         PyObject *self;
1327         PyObject *args;
1328 {
1329         clkoff( );
1330         Py_INCREF(Py_None);
1331         return Py_None;
1332 }
1333
1334 /* void ringbell */
1335
1336 static PyObject *
1337 gl_ringbell(self, args)
1338         PyObject *self;
1339         PyObject *args;
1340 {
1341         ringbell( );
1342         Py_INCREF(Py_None);
1343         return Py_None;
1344 }
1345
1346 /* void gbegin */
1347
1348 static PyObject *
1349 gl_gbegin(self, args)
1350         PyObject *self;
1351         PyObject *args;
1352 {
1353         gbegin( );
1354         Py_INCREF(Py_None);
1355         return Py_None;
1356 }
1357
1358 /* void textinit */
1359
1360 static PyObject *
1361 gl_textinit(self, args)
1362         PyObject *self;
1363         PyObject *args;
1364 {
1365         textinit( );
1366         Py_INCREF(Py_None);
1367         return Py_None;
1368 }
1369
1370 /* void initnames */
1371
1372 static PyObject *
1373 gl_initnames(self, args)
1374         PyObject *self;
1375         PyObject *args;
1376 {
1377         initnames( );
1378         Py_INCREF(Py_None);
1379         return Py_None;
1380 }
1381
1382 /* void pclos */
1383
1384 static PyObject *
1385 gl_pclos(self, args)
1386         PyObject *self;
1387         PyObject *args;
1388 {
1389         pclos( );
1390         Py_INCREF(Py_None);
1391         return Py_None;
1392 }
1393
1394 /* void popname */
1395
1396 static PyObject *
1397 gl_popname(self, args)
1398         PyObject *self;
1399         PyObject *args;
1400 {
1401         popname( );
1402         Py_INCREF(Py_None);
1403         return Py_None;
1404 }
1405
1406 /* void spclos */
1407
1408 static PyObject *
1409 gl_spclos(self, args)
1410         PyObject *self;
1411         PyObject *args;
1412 {
1413         spclos( );
1414         Py_INCREF(Py_None);
1415         return Py_None;
1416 }
1417
1418 /* void zclear */
1419
1420 static PyObject *
1421 gl_zclear(self, args)
1422         PyObject *self;
1423         PyObject *args;
1424 {
1425         zclear( );
1426         Py_INCREF(Py_None);
1427         return Py_None;
1428 }
1429
1430 /* void screenspace */
1431
1432 static PyObject *
1433 gl_screenspace(self, args)
1434         PyObject *self;
1435         PyObject *args;
1436 {
1437         screenspace( );
1438         Py_INCREF(Py_None);
1439         return Py_None;
1440 }
1441
1442 /* void reshapeviewport */
1443
1444 static PyObject *
1445 gl_reshapeviewport(self, args)
1446         PyObject *self;
1447         PyObject *args;
1448 {
1449         reshapeviewport( );
1450         Py_INCREF(Py_None);
1451         return Py_None;
1452 }
1453
1454 /* void winpush */
1455
1456 static PyObject *
1457 gl_winpush(self, args)
1458         PyObject *self;
1459         PyObject *args;
1460 {
1461         winpush( );
1462         Py_INCREF(Py_None);
1463         return Py_None;
1464 }
1465
1466 /* void winpop */
1467
1468 static PyObject *
1469 gl_winpop(self, args)
1470         PyObject *self;
1471         PyObject *args;
1472 {
1473         winpop( );
1474         Py_INCREF(Py_None);
1475         return Py_None;
1476 }
1477
1478 /* void foreground */
1479
1480 static PyObject *
1481 gl_foreground(self, args)
1482         PyObject *self;
1483         PyObject *args;
1484 {
1485         foreground( );
1486         Py_INCREF(Py_None);
1487         return Py_None;
1488 }
1489
1490 /* void endfullscrn */
1491
1492 static PyObject *
1493 gl_endfullscrn(self, args)
1494         PyObject *self;
1495         PyObject *args;
1496 {
1497         endfullscrn( );
1498         Py_INCREF(Py_None);
1499         return Py_None;
1500 }
1501
1502 /* void endpupmode */
1503
1504 static PyObject *
1505 gl_endpupmode(self, args)
1506         PyObject *self;
1507         PyObject *args;
1508 {
1509         endpupmode( );
1510         Py_INCREF(Py_None);
1511         return Py_None;
1512 }
1513
1514 /* void fullscrn */
1515
1516 static PyObject *
1517 gl_fullscrn(self, args)
1518         PyObject *self;
1519         PyObject *args;
1520 {
1521         fullscrn( );
1522         Py_INCREF(Py_None);
1523         return Py_None;
1524 }
1525
1526 /* void pupmode */
1527
1528 static PyObject *
1529 gl_pupmode(self, args)
1530         PyObject *self;
1531         PyObject *args;
1532 {
1533         pupmode( );
1534         Py_INCREF(Py_None);
1535         return Py_None;
1536 }
1537
1538 /* void winconstraints */
1539
1540 static PyObject *
1541 gl_winconstraints(self, args)
1542         PyObject *self;
1543         PyObject *args;
1544 {
1545         winconstraints( );
1546         Py_INCREF(Py_None);
1547         return Py_None;
1548 }
1549
1550 /* void pagecolor short s */
1551
1552 static PyObject *
1553 gl_pagecolor(self, args)
1554         PyObject *self;
1555         PyObject *args;
1556 {
1557         short arg1 ;
1558         if (!getishortarg(args, 1, 0, &arg1))
1559                 return NULL;
1560         pagecolor( arg1 );
1561         Py_INCREF(Py_None);
1562         return Py_None;
1563 }
1564
1565 /* void textcolor short s */
1566
1567 static PyObject *
1568 gl_textcolor(self, args)
1569         PyObject *self;
1570         PyObject *args;
1571 {
1572         short arg1 ;
1573         if (!getishortarg(args, 1, 0, &arg1))
1574                 return NULL;
1575         textcolor( arg1 );
1576         Py_INCREF(Py_None);
1577         return Py_None;
1578 }
1579
1580 /* void color short s */
1581
1582 static PyObject *
1583 gl_color(self, args)
1584         PyObject *self;
1585         PyObject *args;
1586 {
1587         short arg1 ;
1588         if (!getishortarg(args, 1, 0, &arg1))
1589                 return NULL;
1590         color( arg1 );
1591         Py_INCREF(Py_None);
1592         return Py_None;
1593 }
1594
1595 /* void curveit short s */
1596
1597 static PyObject *
1598 gl_curveit(self, args)
1599         PyObject *self;
1600         PyObject *args;
1601 {
1602         short arg1 ;
1603         if (!getishortarg(args, 1, 0, &arg1))
1604                 return NULL;
1605         curveit( arg1 );
1606         Py_INCREF(Py_None);
1607         return Py_None;
1608 }
1609
1610 /* void font short s */
1611
1612 static PyObject *
1613 gl_font(self, args)
1614         PyObject *self;
1615         PyObject *args;
1616 {
1617         short arg1 ;
1618         if (!getishortarg(args, 1, 0, &arg1))
1619                 return NULL;
1620         font( arg1 );
1621         Py_INCREF(Py_None);
1622         return Py_None;
1623 }
1624
1625 /* void linewidth short s */
1626
1627 static PyObject *
1628 gl_linewidth(self, args)
1629         PyObject *self;
1630         PyObject *args;
1631 {
1632         short arg1 ;
1633         if (!getishortarg(args, 1, 0, &arg1))
1634                 return NULL;
1635         linewidth( arg1 );
1636         Py_INCREF(Py_None);
1637         return Py_None;
1638 }
1639
1640 /* void setlinestyle short s */
1641
1642 static PyObject *
1643 gl_setlinestyle(self, args)
1644         PyObject *self;
1645         PyObject *args;
1646 {
1647         short arg1 ;
1648         if (!getishortarg(args, 1, 0, &arg1))
1649                 return NULL;
1650         setlinestyle( arg1 );
1651         Py_INCREF(Py_None);
1652         return Py_None;
1653 }
1654
1655 /* void setmap short s */
1656
1657 static PyObject *
1658 gl_setmap(self, args)
1659         PyObject *self;
1660         PyObject *args;
1661 {
1662         short arg1 ;
1663         if (!getishortarg(args, 1, 0, &arg1))
1664                 return NULL;
1665         setmap( arg1 );
1666         Py_INCREF(Py_None);
1667         return Py_None;
1668 }
1669
1670 /* void swapinterval short s */
1671
1672 static PyObject *
1673 gl_swapinterval(self, args)
1674         PyObject *self;
1675         PyObject *args;
1676 {
1677         short arg1 ;
1678         if (!getishortarg(args, 1, 0, &arg1))
1679                 return NULL;
1680         swapinterval( arg1 );
1681         Py_INCREF(Py_None);
1682         return Py_None;
1683 }
1684
1685 /* void writemask short s */
1686
1687 static PyObject *
1688 gl_writemask(self, args)
1689         PyObject *self;
1690         PyObject *args;
1691 {
1692         short arg1 ;
1693         if (!getishortarg(args, 1, 0, &arg1))
1694                 return NULL;
1695         writemask( arg1 );
1696         Py_INCREF(Py_None);
1697         return Py_None;
1698 }
1699
1700 /* void textwritemask short s */
1701
1702 static PyObject *
1703 gl_textwritemask(self, args)
1704         PyObject *self;
1705         PyObject *args;
1706 {
1707         short arg1 ;
1708         if (!getishortarg(args, 1, 0, &arg1))
1709                 return NULL;
1710         textwritemask( arg1 );
1711         Py_INCREF(Py_None);
1712         return Py_None;
1713 }
1714
1715 /* void qdevice short s */
1716
1717 static PyObject *
1718 gl_qdevice(self, args)
1719         PyObject *self;
1720         PyObject *args;
1721 {
1722         short arg1 ;
1723         if (!getishortarg(args, 1, 0, &arg1))
1724                 return NULL;
1725         qdevice( arg1 );
1726         Py_INCREF(Py_None);
1727         return Py_None;
1728 }
1729
1730 /* void unqdevice short s */
1731
1732 static PyObject *
1733 gl_unqdevice(self, args)
1734         PyObject *self;
1735         PyObject *args;
1736 {
1737         short arg1 ;
1738         if (!getishortarg(args, 1, 0, &arg1))
1739                 return NULL;
1740         unqdevice( arg1 );
1741         Py_INCREF(Py_None);
1742         return Py_None;
1743 }
1744
1745 /* void curvebasis short s */
1746
1747 static PyObject *
1748 gl_curvebasis(self, args)
1749         PyObject *self;
1750         PyObject *args;
1751 {
1752         short arg1 ;
1753         if (!getishortarg(args, 1, 0, &arg1))
1754                 return NULL;
1755         curvebasis( arg1 );
1756         Py_INCREF(Py_None);
1757         return Py_None;
1758 }
1759
1760 /* void curveprecision short s */
1761
1762 static PyObject *
1763 gl_curveprecision(self, args)
1764         PyObject *self;
1765         PyObject *args;
1766 {
1767         short arg1 ;
1768         if (!getishortarg(args, 1, 0, &arg1))
1769                 return NULL;
1770         curveprecision( arg1 );
1771         Py_INCREF(Py_None);
1772         return Py_None;
1773 }
1774
1775 /* void loadname short s */
1776
1777 static PyObject *
1778 gl_loadname(self, args)
1779         PyObject *self;
1780         PyObject *args;
1781 {
1782         short arg1 ;
1783         if (!getishortarg(args, 1, 0, &arg1))
1784                 return NULL;
1785         loadname( arg1 );
1786         Py_INCREF(Py_None);
1787         return Py_None;
1788 }
1789
1790 /* void passthrough short s */
1791
1792 static PyObject *
1793 gl_passthrough(self, args)
1794         PyObject *self;
1795         PyObject *args;
1796 {
1797         short arg1 ;
1798         if (!getishortarg(args, 1, 0, &arg1))
1799                 return NULL;
1800         passthrough( arg1 );
1801         Py_INCREF(Py_None);
1802         return Py_None;
1803 }
1804
1805 /* void pushname short s */
1806
1807 static PyObject *
1808 gl_pushname(self, args)
1809         PyObject *self;
1810         PyObject *args;
1811 {
1812         short arg1 ;
1813         if (!getishortarg(args, 1, 0, &arg1))
1814                 return NULL;
1815         pushname( arg1 );
1816         Py_INCREF(Py_None);
1817         return Py_None;
1818 }
1819
1820 /* void setmonitor short s */
1821
1822 static PyObject *
1823 gl_setmonitor(self, args)
1824         PyObject *self;
1825         PyObject *args;
1826 {
1827         short arg1 ;
1828         if (!getishortarg(args, 1, 0, &arg1))
1829                 return NULL;
1830         setmonitor( arg1 );
1831         Py_INCREF(Py_None);
1832         return Py_None;
1833 }
1834
1835 /* void setshade short s */
1836
1837 static PyObject *
1838 gl_setshade(self, args)
1839         PyObject *self;
1840         PyObject *args;
1841 {
1842         short arg1 ;
1843         if (!getishortarg(args, 1, 0, &arg1))
1844                 return NULL;
1845         setshade( arg1 );
1846         Py_INCREF(Py_None);
1847         return Py_None;
1848 }
1849
1850 /* void setpattern short s */
1851
1852 static PyObject *
1853 gl_setpattern(self, args)
1854         PyObject *self;
1855         PyObject *args;
1856 {
1857         short arg1 ;
1858         if (!getishortarg(args, 1, 0, &arg1))
1859                 return NULL;
1860         setpattern( arg1 );
1861         Py_INCREF(Py_None);
1862         return Py_None;
1863 }
1864
1865 /* void pagewritemask short s */
1866
1867 static PyObject *
1868 gl_pagewritemask(self, args)
1869         PyObject *self;
1870         PyObject *args;
1871 {
1872         short arg1 ;
1873         if (!getishortarg(args, 1, 0, &arg1))
1874                 return NULL;
1875         pagewritemask( arg1 );
1876         Py_INCREF(Py_None);
1877         return Py_None;
1878 }
1879
1880 /* void callobj long s */
1881
1882 static PyObject *
1883 gl_callobj(self, args)
1884         PyObject *self;
1885         PyObject *args;
1886 {
1887         long arg1 ;
1888         if (!getilongarg(args, 1, 0, &arg1))
1889                 return NULL;
1890         callobj( arg1 );
1891         Py_INCREF(Py_None);
1892         return Py_None;
1893 }
1894
1895 /* void delobj long s */
1896
1897 static PyObject *
1898 gl_delobj(self, args)
1899         PyObject *self;
1900         PyObject *args;
1901 {
1902         long arg1 ;
1903         if (!getilongarg(args, 1, 0, &arg1))
1904                 return NULL;
1905         delobj( arg1 );
1906         Py_INCREF(Py_None);
1907         return Py_None;
1908 }
1909
1910 /* void editobj long s */
1911
1912 static PyObject *
1913 gl_editobj(self, args)
1914         PyObject *self;
1915         PyObject *args;
1916 {
1917         long arg1 ;
1918         if (!getilongarg(args, 1, 0, &arg1))
1919                 return NULL;
1920         editobj( arg1 );
1921         Py_INCREF(Py_None);
1922         return Py_None;
1923 }
1924
1925 /* void makeobj long s */
1926
1927 static PyObject *
1928 gl_makeobj(self, args)
1929         PyObject *self;
1930         PyObject *args;
1931 {
1932         long arg1 ;
1933         if (!getilongarg(args, 1, 0, &arg1))
1934                 return NULL;
1935         makeobj( arg1 );
1936         Py_INCREF(Py_None);
1937         return Py_None;
1938 }
1939
1940 /* void maketag long s */
1941
1942 static PyObject *
1943 gl_maketag(self, args)
1944         PyObject *self;
1945         PyObject *args;
1946 {
1947         long arg1 ;
1948         if (!getilongarg(args, 1, 0, &arg1))
1949                 return NULL;
1950         maketag( arg1 );
1951         Py_INCREF(Py_None);
1952         return Py_None;
1953 }
1954
1955 /* void chunksize long s */
1956
1957 static PyObject *
1958 gl_chunksize(self, args)
1959         PyObject *self;
1960         PyObject *args;
1961 {
1962         long arg1 ;
1963         if (!getilongarg(args, 1, 0, &arg1))
1964                 return NULL;
1965         chunksize( arg1 );
1966         Py_INCREF(Py_None);
1967         return Py_None;
1968 }
1969
1970 /* void compactify long s */
1971
1972 static PyObject *
1973 gl_compactify(self, args)
1974         PyObject *self;
1975         PyObject *args;
1976 {
1977         long arg1 ;
1978         if (!getilongarg(args, 1, 0, &arg1))
1979                 return NULL;
1980         compactify( arg1 );
1981         Py_INCREF(Py_None);
1982         return Py_None;
1983 }
1984
1985 /* void deltag long s */
1986
1987 static PyObject *
1988 gl_deltag(self, args)
1989         PyObject *self;
1990         PyObject *args;
1991 {
1992         long arg1 ;
1993         if (!getilongarg(args, 1, 0, &arg1))
1994                 return NULL;
1995         deltag( arg1 );
1996         Py_INCREF(Py_None);
1997         return Py_None;
1998 }
1999
2000 /* void lsrepeat long s */
2001
2002 static PyObject *
2003 gl_lsrepeat(self, args)
2004         PyObject *self;
2005         PyObject *args;
2006 {
2007         long arg1 ;
2008         if (!getilongarg(args, 1, 0, &arg1))
2009                 return NULL;
2010         lsrepeat( arg1 );
2011         Py_INCREF(Py_None);
2012         return Py_None;
2013 }
2014
2015 /* void objinsert long s */
2016
2017 static PyObject *
2018 gl_objinsert(self, args)
2019         PyObject *self;
2020         PyObject *args;
2021 {
2022         long arg1 ;
2023         if (!getilongarg(args, 1, 0, &arg1))
2024                 return NULL;
2025         objinsert( arg1 );
2026         Py_INCREF(Py_None);
2027         return Py_None;
2028 }
2029
2030 /* void objreplace long s */
2031
2032 static PyObject *
2033 gl_objreplace(self, args)
2034         PyObject *self;
2035         PyObject *args;
2036 {
2037         long arg1 ;
2038         if (!getilongarg(args, 1, 0, &arg1))
2039                 return NULL;
2040         objreplace( arg1 );
2041         Py_INCREF(Py_None);
2042         return Py_None;
2043 }
2044
2045 /* void winclose long s */
2046
2047 static PyObject *
2048 gl_winclose(self, args)
2049         PyObject *self;
2050         PyObject *args;
2051 {
2052         long arg1 ;
2053         if (!getilongarg(args, 1, 0, &arg1))
2054                 return NULL;
2055         winclose( arg1 );
2056         Py_INCREF(Py_None);
2057         return Py_None;
2058 }
2059
2060 /* void blanktime long s */
2061
2062 static PyObject *
2063 gl_blanktime(self, args)
2064         PyObject *self;
2065         PyObject *args;
2066 {
2067         long arg1 ;
2068         if (!getilongarg(args, 1, 0, &arg1))
2069                 return NULL;
2070         blanktime( arg1 );
2071         Py_INCREF(Py_None);
2072         return Py_None;
2073 }
2074
2075 /* void freepup long s */
2076
2077 static PyObject *
2078 gl_freepup(self, args)
2079         PyObject *self;
2080         PyObject *args;
2081 {
2082         long arg1 ;
2083         if (!getilongarg(args, 1, 0, &arg1))
2084                 return NULL;
2085         freepup( arg1 );
2086         Py_INCREF(Py_None);
2087         return Py_None;
2088 }
2089
2090 /* void backbuffer long s */
2091
2092 static PyObject *
2093 gl_backbuffer(self, args)
2094         PyObject *self;
2095         PyObject *args;
2096 {
2097         long arg1 ;
2098         if (!getilongarg(args, 1, 0, &arg1))
2099                 return NULL;
2100         backbuffer( arg1 );
2101         Py_INCREF(Py_None);
2102         return Py_None;
2103 }
2104
2105 /* void frontbuffer long s */
2106
2107 static PyObject *
2108 gl_frontbuffer(self, args)
2109         PyObject *self;
2110         PyObject *args;
2111 {
2112         long arg1 ;
2113         if (!getilongarg(args, 1, 0, &arg1))
2114                 return NULL;
2115         frontbuffer( arg1 );
2116         Py_INCREF(Py_None);
2117         return Py_None;
2118 }
2119
2120 /* void lsbackup long s */
2121
2122 static PyObject *
2123 gl_lsbackup(self, args)
2124         PyObject *self;
2125         PyObject *args;
2126 {
2127         long arg1 ;
2128         if (!getilongarg(args, 1, 0, &arg1))
2129                 return NULL;
2130         lsbackup( arg1 );
2131         Py_INCREF(Py_None);
2132         return Py_None;
2133 }
2134
2135 /* void resetls long s */
2136
2137 static PyObject *
2138 gl_resetls(self, args)
2139         PyObject *self;
2140         PyObject *args;
2141 {
2142         long arg1 ;
2143         if (!getilongarg(args, 1, 0, &arg1))
2144                 return NULL;
2145         resetls( arg1 );
2146         Py_INCREF(Py_None);
2147         return Py_None;
2148 }
2149
2150 /* void lampon long s */
2151
2152 static PyObject *
2153 gl_lampon(self, args)
2154         PyObject *self;
2155         PyObject *args;
2156 {
2157         long arg1 ;
2158         if (!getilongarg(args, 1, 0, &arg1))
2159                 return NULL;
2160         lampon( arg1 );
2161         Py_INCREF(Py_None);
2162         return Py_None;
2163 }
2164
2165 /* void lampoff long s */
2166
2167 static PyObject *
2168 gl_lampoff(self, args)
2169         PyObject *self;
2170         PyObject *args;
2171 {
2172         long arg1 ;
2173         if (!getilongarg(args, 1, 0, &arg1))
2174                 return NULL;
2175         lampoff( arg1 );
2176         Py_INCREF(Py_None);
2177         return Py_None;
2178 }
2179
2180 /* void setbell long s */
2181
2182 static PyObject *
2183 gl_setbell(self, args)
2184         PyObject *self;
2185         PyObject *args;
2186 {
2187         long arg1 ;
2188         if (!getilongarg(args, 1, 0, &arg1))
2189                 return NULL;
2190         setbell( arg1 );
2191         Py_INCREF(Py_None);
2192         return Py_None;
2193 }
2194
2195 /* void blankscreen long s */
2196
2197 static PyObject *
2198 gl_blankscreen(self, args)
2199         PyObject *self;
2200         PyObject *args;
2201 {
2202         long arg1 ;
2203         if (!getilongarg(args, 1, 0, &arg1))
2204                 return NULL;
2205         blankscreen( arg1 );
2206         Py_INCREF(Py_None);
2207         return Py_None;
2208 }
2209
2210 /* void depthcue long s */
2211
2212 static PyObject *
2213 gl_depthcue(self, args)
2214         PyObject *self;
2215         PyObject *args;
2216 {
2217         long arg1 ;
2218         if (!getilongarg(args, 1, 0, &arg1))
2219                 return NULL;
2220         depthcue( arg1 );
2221         Py_INCREF(Py_None);
2222         return Py_None;
2223 }
2224
2225 /* void zbuffer long s */
2226
2227 static PyObject *
2228 gl_zbuffer(self, args)
2229         PyObject *self;
2230         PyObject *args;
2231 {
2232         long arg1 ;
2233         if (!getilongarg(args, 1, 0, &arg1))
2234                 return NULL;
2235         zbuffer( arg1 );
2236         Py_INCREF(Py_None);
2237         return Py_None;
2238 }
2239
2240 /* void backface long s */
2241
2242 static PyObject *
2243 gl_backface(self, args)
2244         PyObject *self;
2245         PyObject *args;
2246 {
2247         long arg1 ;
2248         if (!getilongarg(args, 1, 0, &arg1))
2249                 return NULL;
2250         backface( arg1 );
2251         Py_INCREF(Py_None);
2252         return Py_None;
2253 }
2254
2255 /* void cmov2i long s long s */
2256
2257 static PyObject *
2258 gl_cmov2i(self, args)
2259         PyObject *self;
2260         PyObject *args;
2261 {
2262         long arg1 ;
2263         long arg2 ;
2264         if (!getilongarg(args, 2, 0, &arg1))
2265                 return NULL;
2266         if (!getilongarg(args, 2, 1, &arg2))
2267                 return NULL;
2268         cmov2i( arg1 , arg2 );
2269         Py_INCREF(Py_None);
2270         return Py_None;
2271 }
2272
2273 /* void draw2i long s long s */
2274
2275 static PyObject *
2276 gl_draw2i(self, args)
2277         PyObject *self;
2278         PyObject *args;
2279 {
2280         long arg1 ;
2281         long arg2 ;
2282         if (!getilongarg(args, 2, 0, &arg1))
2283                 return NULL;
2284         if (!getilongarg(args, 2, 1, &arg2))
2285                 return NULL;
2286         draw2i( arg1 , arg2 );
2287         Py_INCREF(Py_None);
2288         return Py_None;
2289 }
2290
2291 /* void move2i long s long s */
2292
2293 static PyObject *
2294 gl_move2i(self, args)
2295         PyObject *self;
2296         PyObject *args;
2297 {
2298         long arg1 ;
2299         long arg2 ;
2300         if (!getilongarg(args, 2, 0, &arg1))
2301                 return NULL;
2302         if (!getilongarg(args, 2, 1, &arg2))
2303                 return NULL;
2304         move2i( arg1 , arg2 );
2305         Py_INCREF(Py_None);
2306         return Py_None;
2307 }
2308
2309 /* void pnt2i long s long s */
2310
2311 static PyObject *
2312 gl_pnt2i(self, args)
2313         PyObject *self;
2314         PyObject *args;
2315 {
2316         long arg1 ;
2317         long arg2 ;
2318         if (!getilongarg(args, 2, 0, &arg1))
2319                 return NULL;
2320         if (!getilongarg(args, 2, 1, &arg2))
2321                 return NULL;
2322         pnt2i( arg1 , arg2 );
2323         Py_INCREF(Py_None);
2324         return Py_None;
2325 }
2326
2327 /* void patchbasis long s long s */
2328
2329 static PyObject *
2330 gl_patchbasis(self, args)
2331         PyObject *self;
2332         PyObject *args;
2333 {
2334         long arg1 ;
2335         long arg2 ;
2336         if (!getilongarg(args, 2, 0, &arg1))
2337                 return NULL;
2338         if (!getilongarg(args, 2, 1, &arg2))
2339                 return NULL;
2340         patchbasis( arg1 , arg2 );
2341         Py_INCREF(Py_None);
2342         return Py_None;
2343 }
2344
2345 /* void patchprecision long s long s */
2346
2347 static PyObject *
2348 gl_patchprecision(self, args)
2349         PyObject *self;
2350         PyObject *args;
2351 {
2352         long arg1 ;
2353         long arg2 ;
2354         if (!getilongarg(args, 2, 0, &arg1))
2355                 return NULL;
2356         if (!getilongarg(args, 2, 1, &arg2))
2357                 return NULL;
2358         patchprecision( arg1 , arg2 );
2359         Py_INCREF(Py_None);
2360         return Py_None;
2361 }
2362
2363 /* void pdr2i long s long s */
2364
2365 static PyObject *
2366 gl_pdr2i(self, args)
2367         PyObject *self;
2368         PyObject *args;
2369 {
2370         long arg1 ;
2371         long arg2 ;
2372         if (!getilongarg(args, 2, 0, &arg1))
2373                 return NULL;
2374         if (!getilongarg(args, 2, 1, &arg2))
2375                 return NULL;
2376         pdr2i( arg1 , arg2 );
2377         Py_INCREF(Py_None);
2378         return Py_None;
2379 }
2380
2381 /* void pmv2i long s long s */
2382
2383 static PyObject *
2384 gl_pmv2i(self, args)
2385         PyObject *self;
2386         PyObject *args;
2387 {
2388         long arg1 ;
2389         long arg2 ;
2390         if (!getilongarg(args, 2, 0, &arg1))
2391                 return NULL;
2392         if (!getilongarg(args, 2, 1, &arg2))
2393                 return NULL;
2394         pmv2i( arg1 , arg2 );
2395         Py_INCREF(Py_None);
2396         return Py_None;
2397 }
2398
2399 /* void rpdr2i long s long s */
2400
2401 static PyObject *
2402 gl_rpdr2i(self, args)
2403         PyObject *self;
2404         PyObject *args;
2405 {
2406         long arg1 ;
2407         long arg2 ;
2408         if (!getilongarg(args, 2, 0, &arg1))
2409                 return NULL;
2410         if (!getilongarg(args, 2, 1, &arg2))
2411                 return NULL;
2412         rpdr2i( arg1 , arg2 );
2413         Py_INCREF(Py_None);
2414         return Py_None;
2415 }
2416
2417 /* void rpmv2i long s long s */
2418
2419 static PyObject *
2420 gl_rpmv2i(self, args)
2421         PyObject *self;
2422         PyObject *args;
2423 {
2424         long arg1 ;
2425         long arg2 ;
2426         if (!getilongarg(args, 2, 0, &arg1))
2427                 return NULL;
2428         if (!getilongarg(args, 2, 1, &arg2))
2429                 return NULL;
2430         rpmv2i( arg1 , arg2 );
2431         Py_INCREF(Py_None);
2432         return Py_None;
2433 }
2434
2435 /* void xfpt2i long s long s */
2436
2437 static PyObject *
2438 gl_xfpt2i(self, args)
2439         PyObject *self;
2440         PyObject *args;
2441 {
2442         long arg1 ;
2443         long arg2 ;
2444         if (!getilongarg(args, 2, 0, &arg1))
2445                 return NULL;
2446         if (!getilongarg(args, 2, 1, &arg2))
2447                 return NULL;
2448         xfpt2i( arg1 , arg2 );
2449         Py_INCREF(Py_None);
2450         return Py_None;
2451 }
2452
2453 /* void objdelete long s long s */
2454
2455 static PyObject *
2456 gl_objdelete(self, args)
2457         PyObject *self;
2458         PyObject *args;
2459 {
2460         long arg1 ;
2461         long arg2 ;
2462         if (!getilongarg(args, 2, 0, &arg1))
2463                 return NULL;
2464         if (!getilongarg(args, 2, 1, &arg2))
2465                 return NULL;
2466         objdelete( arg1 , arg2 );
2467         Py_INCREF(Py_None);
2468         return Py_None;
2469 }
2470
2471 /* void patchcurves long s long s */
2472
2473 static PyObject *
2474 gl_patchcurves(self, args)
2475         PyObject *self;
2476         PyObject *args;
2477 {
2478         long arg1 ;
2479         long arg2 ;
2480         if (!getilongarg(args, 2, 0, &arg1))
2481                 return NULL;
2482         if (!getilongarg(args, 2, 1, &arg2))
2483                 return NULL;
2484         patchcurves( arg1 , arg2 );
2485         Py_INCREF(Py_None);
2486         return Py_None;
2487 }
2488
2489 /* void minsize long s long s */
2490
2491 static PyObject *
2492 gl_minsize(self, args)
2493         PyObject *self;
2494         PyObject *args;
2495 {
2496         long arg1 ;
2497         long arg2 ;
2498         if (!getilongarg(args, 2, 0, &arg1))
2499                 return NULL;
2500         if (!getilongarg(args, 2, 1, &arg2))
2501                 return NULL;
2502         minsize( arg1 , arg2 );
2503         Py_INCREF(Py_None);
2504         return Py_None;
2505 }
2506
2507 /* void maxsize long s long s */
2508
2509 static PyObject *
2510 gl_maxsize(self, args)
2511         PyObject *self;
2512         PyObject *args;
2513 {
2514         long arg1 ;
2515         long arg2 ;
2516         if (!getilongarg(args, 2, 0, &arg1))
2517                 return NULL;
2518         if (!getilongarg(args, 2, 1, &arg2))
2519                 return NULL;
2520         maxsize( arg1 , arg2 );
2521         Py_INCREF(Py_None);
2522         return Py_None;
2523 }
2524
2525 /* void keepaspect long s long s */
2526
2527 static PyObject *
2528 gl_keepaspect(self, args)
2529         PyObject *self;
2530         PyObject *args;
2531 {
2532         long arg1 ;
2533         long arg2 ;
2534         if (!getilongarg(args, 2, 0, &arg1))
2535                 return NULL;
2536         if (!getilongarg(args, 2, 1, &arg2))
2537                 return NULL;
2538         keepaspect( arg1 , arg2 );
2539         Py_INCREF(Py_None);
2540         return Py_None;
2541 }
2542
2543 /* void prefsize long s long s */
2544
2545 static PyObject *
2546 gl_prefsize(self, args)
2547         PyObject *self;
2548         PyObject *args;
2549 {
2550         long arg1 ;
2551         long arg2 ;
2552         if (!getilongarg(args, 2, 0, &arg1))
2553                 return NULL;
2554         if (!getilongarg(args, 2, 1, &arg2))
2555                 return NULL;
2556         prefsize( arg1 , arg2 );
2557         Py_INCREF(Py_None);
2558         return Py_None;
2559 }
2560
2561 /* void stepunit long s long s */
2562
2563 static PyObject *
2564 gl_stepunit(self, args)
2565         PyObject *self;
2566         PyObject *args;
2567 {
2568         long arg1 ;
2569         long arg2 ;
2570         if (!getilongarg(args, 2, 0, &arg1))
2571                 return NULL;
2572         if (!getilongarg(args, 2, 1, &arg2))
2573                 return NULL;
2574         stepunit( arg1 , arg2 );
2575         Py_INCREF(Py_None);
2576         return Py_None;
2577 }
2578
2579 /* void fudge long s long s */
2580
2581 static PyObject *
2582 gl_fudge(self, args)
2583         PyObject *self;
2584         PyObject *args;
2585 {
2586         long arg1 ;
2587         long arg2 ;
2588         if (!getilongarg(args, 2, 0, &arg1))
2589                 return NULL;
2590         if (!getilongarg(args, 2, 1, &arg2))
2591                 return NULL;
2592         fudge( arg1 , arg2 );
2593         Py_INCREF(Py_None);
2594         return Py_None;
2595 }
2596
2597 /* void winmove long s long s */
2598
2599 static PyObject *
2600 gl_winmove(self, args)
2601         PyObject *self;
2602         PyObject *args;
2603 {
2604         long arg1 ;
2605         long arg2 ;
2606         if (!getilongarg(args, 2, 0, &arg1))
2607                 return NULL;
2608         if (!getilongarg(args, 2, 1, &arg2))
2609                 return NULL;
2610         winmove( arg1 , arg2 );
2611         Py_INCREF(Py_None);
2612         return Py_None;
2613 }
2614
2615 /* void attachcursor short s short s */
2616
2617 static PyObject *
2618 gl_attachcursor(self, args)
2619         PyObject *self;
2620         PyObject *args;
2621 {
2622         short arg1 ;
2623         short arg2 ;
2624         if (!getishortarg(args, 2, 0, &arg1))
2625                 return NULL;
2626         if (!getishortarg(args, 2, 1, &arg2))
2627                 return NULL;
2628         attachcursor( arg1 , arg2 );
2629         Py_INCREF(Py_None);
2630         return Py_None;
2631 }
2632
2633 /* void deflinestyle short s short s */
2634
2635 static PyObject *
2636 gl_deflinestyle(self, args)
2637         PyObject *self;
2638         PyObject *args;
2639 {
2640         short arg1 ;
2641         short arg2 ;
2642         if (!getishortarg(args, 2, 0, &arg1))
2643                 return NULL;
2644         if (!getishortarg(args, 2, 1, &arg2))
2645                 return NULL;
2646         deflinestyle( arg1 , arg2 );
2647         Py_INCREF(Py_None);
2648         return Py_None;
2649 }
2650
2651 /* void noise short s short s */
2652
2653 static PyObject *
2654 gl_noise(self, args)
2655         PyObject *self;
2656         PyObject *args;
2657 {
2658         short arg1 ;
2659         short arg2 ;
2660         if (!getishortarg(args, 2, 0, &arg1))
2661                 return NULL;
2662         if (!getishortarg(args, 2, 1, &arg2))
2663                 return NULL;
2664         noise( arg1 , arg2 );
2665         Py_INCREF(Py_None);
2666         return Py_None;
2667 }
2668
2669 /* void picksize short s short s */
2670
2671 static PyObject *
2672 gl_picksize(self, args)
2673         PyObject *self;
2674         PyObject *args;
2675 {
2676         short arg1 ;
2677         short arg2 ;
2678         if (!getishortarg(args, 2, 0, &arg1))
2679                 return NULL;
2680         if (!getishortarg(args, 2, 1, &arg2))
2681                 return NULL;
2682         picksize( arg1 , arg2 );
2683         Py_INCREF(Py_None);
2684         return Py_None;
2685 }
2686
2687 /* void qenter short s short s */
2688
2689 static PyObject *
2690 gl_qenter(self, args)
2691         PyObject *self;
2692         PyObject *args;
2693 {
2694         short arg1 ;
2695         short arg2 ;
2696         if (!getishortarg(args, 2, 0, &arg1))
2697                 return NULL;
2698         if (!getishortarg(args, 2, 1, &arg2))
2699                 return NULL;
2700         qenter( arg1 , arg2 );
2701         Py_INCREF(Py_None);
2702         return Py_None;
2703 }
2704
2705 /* void setdepth short s short s */
2706
2707 static PyObject *
2708 gl_setdepth(self, args)
2709         PyObject *self;
2710         PyObject *args;
2711 {
2712         short arg1 ;
2713         short arg2 ;
2714         if (!getishortarg(args, 2, 0, &arg1))
2715                 return NULL;
2716         if (!getishortarg(args, 2, 1, &arg2))
2717                 return NULL;
2718         setdepth( arg1 , arg2 );
2719         Py_INCREF(Py_None);
2720         return Py_None;
2721 }
2722
2723 /* void cmov2s short s short s */
2724
2725 static PyObject *
2726 gl_cmov2s(self, args)
2727         PyObject *self;
2728         PyObject *args;
2729 {
2730         short arg1 ;
2731         short arg2 ;
2732         if (!getishortarg(args, 2, 0, &arg1))
2733                 return NULL;
2734         if (!getishortarg(args, 2, 1, &arg2))
2735                 return NULL;
2736         cmov2s( arg1 , arg2 );
2737         Py_INCREF(Py_None);
2738         return Py_None;
2739 }
2740
2741 /* void draw2s short s short s */
2742
2743 static PyObject *
2744 gl_draw2s(self, args)
2745         PyObject *self;
2746         PyObject *args;
2747 {
2748         short arg1 ;
2749         short arg2 ;
2750         if (!getishortarg(args, 2, 0, &arg1))
2751                 return NULL;
2752         if (!getishortarg(args, 2, 1, &arg2))
2753                 return NULL;
2754         draw2s( arg1 , arg2 );
2755         Py_INCREF(Py_None);
2756         return Py_None;
2757 }
2758
2759 /* void move2s short s short s */
2760
2761 static PyObject *
2762 gl_move2s(self, args)
2763         PyObject *self;
2764         PyObject *args;
2765 {
2766         short arg1 ;
2767         short arg2 ;
2768         if (!getishortarg(args, 2, 0, &arg1))
2769                 return NULL;
2770         if (!getishortarg(args, 2, 1, &arg2))
2771                 return NULL;
2772         move2s( arg1 , arg2 );
2773         Py_INCREF(Py_None);
2774         return Py_None;
2775 }
2776
2777 /* void pdr2s short s short s */
2778
2779 static PyObject *
2780 gl_pdr2s(self, args)
2781         PyObject *self;
2782         PyObject *args;
2783 {
2784         short arg1 ;
2785         short arg2 ;
2786         if (!getishortarg(args, 2, 0, &arg1))
2787                 return NULL;
2788         if (!getishortarg(args, 2, 1, &arg2))
2789                 return NULL;
2790         pdr2s( arg1 , arg2 );
2791         Py_INCREF(Py_None);
2792         return Py_None;
2793 }
2794
2795 /* void pmv2s short s short s */
2796
2797 static PyObject *
2798 gl_pmv2s(self, args)
2799         PyObject *self;
2800         PyObject *args;
2801 {
2802         short arg1 ;
2803         short arg2 ;
2804         if (!getishortarg(args, 2, 0, &arg1))
2805                 return NULL;
2806         if (!getishortarg(args, 2, 1, &arg2))
2807                 return NULL;
2808         pmv2s( arg1 , arg2 );
2809         Py_INCREF(Py_None);
2810         return Py_None;
2811 }
2812
2813 /* void pnt2s short s short s */
2814
2815 static PyObject *
2816 gl_pnt2s(self, args)
2817         PyObject *self;
2818         PyObject *args;
2819 {
2820         short arg1 ;
2821         short arg2 ;
2822         if (!getishortarg(args, 2, 0, &arg1))
2823                 return NULL;
2824         if (!getishortarg(args, 2, 1, &arg2))
2825                 return NULL;
2826         pnt2s( arg1 , arg2 );
2827         Py_INCREF(Py_None);
2828         return Py_None;
2829 }
2830
2831 /* void rdr2s short s short s */
2832
2833 static PyObject *
2834 gl_rdr2s(self, args)
2835         PyObject *self;
2836         PyObject *args;
2837 {
2838         short arg1 ;
2839         short arg2 ;
2840         if (!getishortarg(args, 2, 0, &arg1))
2841                 return NULL;
2842         if (!getishortarg(args, 2, 1, &arg2))
2843                 return NULL;
2844         rdr2s( arg1 , arg2 );
2845         Py_INCREF(Py_None);
2846         return Py_None;
2847 }
2848
2849 /* void rmv2s short s short s */
2850
2851 static PyObject *
2852 gl_rmv2s(self, args)
2853         PyObject *self;
2854         PyObject *args;
2855 {
2856         short arg1 ;
2857         short arg2 ;
2858         if (!getishortarg(args, 2, 0, &arg1))
2859                 return NULL;
2860         if (!getishortarg(args, 2, 1, &arg2))
2861                 return NULL;
2862         rmv2s( arg1 , arg2 );
2863         Py_INCREF(Py_None);
2864         return Py_None;
2865 }
2866
2867 /* void rpdr2s short s short s */
2868
2869 static PyObject *
2870 gl_rpdr2s(self, args)
2871         PyObject *self;
2872         PyObject *args;
2873 {
2874         short arg1 ;
2875         short arg2 ;
2876         if (!getishortarg(args, 2, 0, &arg1))
2877                 return NULL;
2878         if (!getishortarg(args, 2, 1, &arg2))
2879                 return NULL;
2880         rpdr2s( arg1 , arg2 );
2881         Py_INCREF(Py_None);
2882         return Py_None;
2883 }
2884
2885 /* void rpmv2s short s short s */
2886
2887 static PyObject *
2888 gl_rpmv2s(self, args)
2889         PyObject *self;
2890         PyObject *args;
2891 {
2892         short arg1 ;
2893         short arg2 ;
2894         if (!getishortarg(args, 2, 0, &arg1))
2895                 return NULL;
2896         if (!getishortarg(args, 2, 1, &arg2))
2897                 return NULL;
2898         rpmv2s( arg1 , arg2 );
2899         Py_INCREF(Py_None);
2900         return Py_None;
2901 }
2902
2903 /* void xfpt2s short s short s */
2904
2905 static PyObject *
2906 gl_xfpt2s(self, args)
2907         PyObject *self;
2908         PyObject *args;
2909 {
2910         short arg1 ;
2911         short arg2 ;
2912         if (!getishortarg(args, 2, 0, &arg1))
2913                 return NULL;
2914         if (!getishortarg(args, 2, 1, &arg2))
2915                 return NULL;
2916         xfpt2s( arg1 , arg2 );
2917         Py_INCREF(Py_None);
2918         return Py_None;
2919 }
2920
2921 /* void cmov2 float s float s */
2922
2923 static PyObject *
2924 gl_cmov2(self, args)
2925         PyObject *self;
2926         PyObject *args;
2927 {
2928         float arg1 ;
2929         float arg2 ;
2930         if (!getifloatarg(args, 2, 0, &arg1))
2931                 return NULL;
2932         if (!getifloatarg(args, 2, 1, &arg2))
2933                 return NULL;
2934         cmov2( arg1 , arg2 );
2935         Py_INCREF(Py_None);
2936         return Py_None;
2937 }
2938
2939 /* void draw2 float s float s */
2940
2941 static PyObject *
2942 gl_draw2(self, args)
2943         PyObject *self;
2944         PyObject *args;
2945 {
2946         float arg1 ;
2947         float arg2 ;
2948         if (!getifloatarg(args, 2, 0, &arg1))
2949                 return NULL;
2950         if (!getifloatarg(args, 2, 1, &arg2))
2951                 return NULL;
2952         draw2( arg1 , arg2 );
2953         Py_INCREF(Py_None);
2954         return Py_None;
2955 }
2956
2957 /* void move2 float s float s */
2958
2959 static PyObject *
2960 gl_move2(self, args)
2961         PyObject *self;
2962         PyObject *args;
2963 {
2964         float arg1 ;
2965         float arg2 ;
2966         if (!getifloatarg(args, 2, 0, &arg1))
2967                 return NULL;
2968         if (!getifloatarg(args, 2, 1, &arg2))
2969                 return NULL;
2970         move2( arg1 , arg2 );
2971         Py_INCREF(Py_None);
2972         return Py_None;
2973 }
2974
2975 /* void pnt2 float s float s */
2976
2977 static PyObject *
2978 gl_pnt2(self, args)
2979         PyObject *self;
2980         PyObject *args;
2981 {
2982         float arg1 ;
2983         float arg2 ;
2984         if (!getifloatarg(args, 2, 0, &arg1))
2985                 return NULL;
2986         if (!getifloatarg(args, 2, 1, &arg2))
2987                 return NULL;
2988         pnt2( arg1 , arg2 );
2989         Py_INCREF(Py_None);
2990         return Py_None;
2991 }
2992
2993 /* void pdr2 float s float s */
2994
2995 static PyObject *
2996 gl_pdr2(self, args)
2997         PyObject *self;
2998         PyObject *args;
2999 {
3000         float arg1 ;
3001         float arg2 ;
3002         if (!getifloatarg(args, 2, 0, &arg1))
3003                 return NULL;
3004         if (!getifloatarg(args, 2, 1, &arg2))
3005                 return NULL;
3006         pdr2( arg1 , arg2 );
3007         Py_INCREF(Py_None);
3008         return Py_None;
3009 }
3010
3011 /* void pmv2 float s float s */
3012
3013 static PyObject *
3014 gl_pmv2(self, args)
3015         PyObject *self;
3016         PyObject *args;
3017 {
3018         float arg1 ;
3019         float arg2 ;
3020         if (!getifloatarg(args, 2, 0, &arg1))
3021                 return NULL;
3022         if (!getifloatarg(args, 2, 1, &arg2))
3023                 return NULL;
3024         pmv2( arg1 , arg2 );
3025         Py_INCREF(Py_None);
3026         return Py_None;
3027 }
3028
3029 /* void rdr2 float s float s */
3030
3031 static PyObject *
3032 gl_rdr2(self, args)
3033         PyObject *self;
3034         PyObject *args;
3035 {
3036         float arg1 ;
3037         float arg2 ;
3038         if (!getifloatarg(args, 2, 0, &arg1))
3039                 return NULL;
3040         if (!getifloatarg(args, 2, 1, &arg2))
3041                 return NULL;
3042         rdr2( arg1 , arg2 );
3043         Py_INCREF(Py_None);
3044         return Py_None;
3045 }
3046
3047 /* void rmv2 float s float s */
3048
3049 static PyObject *
3050 gl_rmv2(self, args)
3051         PyObject *self;
3052         PyObject *args;
3053 {
3054         float arg1 ;
3055         float arg2 ;
3056         if (!getifloatarg(args, 2, 0, &arg1))
3057                 return NULL;
3058         if (!getifloatarg(args, 2, 1, &arg2))
3059                 return NULL;
3060         rmv2( arg1 , arg2 );
3061         Py_INCREF(Py_None);
3062         return Py_None;
3063 }
3064
3065 /* void rpdr2 float s float s */
3066
3067 static PyObject *
3068 gl_rpdr2(self, args)
3069         PyObject *self;
3070         PyObject *args;
3071 {
3072         float arg1 ;
3073         float arg2 ;
3074         if (!getifloatarg(args, 2, 0, &arg1))
3075                 return NULL;
3076         if (!getifloatarg(args, 2, 1, &arg2))
3077                 return NULL;
3078         rpdr2( arg1 , arg2 );
3079         Py_INCREF(Py_None);
3080         return Py_None;
3081 }
3082
3083 /* void rpmv2 float s float s */
3084
3085 static PyObject *
3086 gl_rpmv2(self, args)
3087         PyObject *self;
3088         PyObject *args;
3089 {
3090         float arg1 ;
3091         float arg2 ;
3092         if (!getifloatarg(args, 2, 0, &arg1))
3093                 return NULL;
3094         if (!getifloatarg(args, 2, 1, &arg2))
3095                 return NULL;
3096         rpmv2( arg1 , arg2 );
3097         Py_INCREF(Py_None);
3098         return Py_None;
3099 }
3100
3101 /* void xfpt2 float s float s */
3102
3103 static PyObject *
3104 gl_xfpt2(self, args)
3105         PyObject *self;
3106         PyObject *args;
3107 {
3108         float arg1 ;
3109         float arg2 ;
3110         if (!getifloatarg(args, 2, 0, &arg1))
3111                 return NULL;
3112         if (!getifloatarg(args, 2, 1, &arg2))
3113                 return NULL;
3114         xfpt2( arg1 , arg2 );
3115         Py_INCREF(Py_None);
3116         return Py_None;
3117 }
3118
3119 /* void loadmatrix float s[4*4] */
3120
3121 static PyObject *
3122 gl_loadmatrix(self, args)
3123         PyObject *self;
3124         PyObject *args;
3125 {
3126         float arg1 [ 4 ] [ 4 ] ;
3127         if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
3128                 return NULL;
3129         loadmatrix( arg1 );
3130         Py_INCREF(Py_None);
3131         return Py_None;
3132 }
3133
3134 /* void multmatrix float s[4*4] */
3135
3136 static PyObject *
3137 gl_multmatrix(self, args)
3138         PyObject *self;
3139         PyObject *args;
3140 {
3141         float arg1 [ 4 ] [ 4 ] ;
3142         if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
3143                 return NULL;
3144         multmatrix( arg1 );
3145         Py_INCREF(Py_None);
3146         return Py_None;
3147 }
3148
3149 /* void crv float s[3*4] */
3150
3151 static PyObject *
3152 gl_crv(self, args)
3153         PyObject *self;
3154         PyObject *args;
3155 {
3156         float arg1 [ 4 ] [ 3 ] ;
3157         if (!getifloatarray(args, 1, 0, 3 * 4 , (float *) arg1))
3158                 return NULL;
3159         crv( arg1 );
3160         Py_INCREF(Py_None);
3161         return Py_None;
3162 }
3163
3164 /* void rcrv float s[4*4] */
3165
3166 static PyObject *
3167 gl_rcrv(self, args)
3168         PyObject *self;
3169         PyObject *args;
3170 {
3171         float arg1 [ 4 ] [ 4 ] ;
3172         if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
3173                 return NULL;
3174         rcrv( arg1 );
3175         Py_INCREF(Py_None);
3176         return Py_None;
3177 }
3178
3179 /* void addtopup long s char *s long s */
3180
3181 static PyObject *
3182 gl_addtopup(self, args)
3183         PyObject *self;
3184         PyObject *args;
3185 {
3186         long arg1 ;
3187         string arg2 ;
3188         long arg3 ;
3189         if (!getilongarg(args, 3, 0, &arg1))
3190                 return NULL;
3191         if (!getistringarg(args, 3, 1, &arg2))
3192                 return NULL;
3193         if (!getilongarg(args, 3, 2, &arg3))
3194                 return NULL;
3195         addtopup( arg1 , arg2 , arg3 );
3196         Py_INCREF(Py_None);
3197         return Py_None;
3198 }
3199
3200 /* void charstr char *s */
3201
3202 static PyObject *
3203 gl_charstr(self, args)
3204         PyObject *self;
3205         PyObject *args;
3206 {
3207         string arg1 ;
3208         if (!getistringarg(args, 1, 0, &arg1))
3209                 return NULL;
3210         charstr( arg1 );
3211         Py_INCREF(Py_None);
3212         return Py_None;
3213 }
3214
3215 /* void getport char *s */
3216
3217 static PyObject *
3218 gl_getport(self, args)
3219         PyObject *self;
3220         PyObject *args;
3221 {
3222         string arg1 ;
3223         if (!getistringarg(args, 1, 0, &arg1))
3224                 return NULL;
3225         getport( arg1 );
3226         Py_INCREF(Py_None);
3227         return Py_None;
3228 }
3229
3230 /* long strwidth char *s */
3231
3232 static PyObject *
3233 gl_strwidth(self, args)
3234         PyObject *self;
3235         PyObject *args;
3236 {
3237         long retval;
3238         string arg1 ;
3239         if (!getistringarg(args, 1, 0, &arg1))
3240                 return NULL;
3241         retval = strwidth( arg1 );
3242         return mknewlongobject(retval);
3243 }
3244
3245 /* long winopen char *s */
3246
3247 static PyObject *
3248 gl_winopen(self, args)
3249         PyObject *self;
3250         PyObject *args;
3251 {
3252         long retval;
3253         string arg1 ;
3254         if (!getistringarg(args, 1, 0, &arg1))
3255                 return NULL;
3256         retval = winopen( arg1 );
3257         return mknewlongobject(retval);
3258 }
3259
3260 /* void wintitle char *s */
3261
3262 static PyObject *
3263 gl_wintitle(self, args)
3264         PyObject *self;
3265         PyObject *args;
3266 {
3267         string arg1 ;
3268         if (!getistringarg(args, 1, 0, &arg1))
3269                 return NULL;
3270         wintitle( arg1 );
3271         Py_INCREF(Py_None);
3272         return Py_None;
3273 }
3274
3275 /* void polf long s float s[3*arg1] */
3276
3277 static PyObject *
3278 gl_polf(self, args)
3279         PyObject *self;
3280         PyObject *args;
3281 {
3282         long arg1 ;
3283         float (* arg2) [ 3 ] ;
3284         if (!getilongarraysize(args, 1, 0, &arg1))
3285                 return NULL;
3286         arg1 = arg1 / 3;
3287         if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
3288                 return PyErr_NoMemory();
3289         if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
3290                 return NULL;
3291         polf( arg1 , arg2 );
3292         PyMem_DEL(arg2);
3293         Py_INCREF(Py_None);
3294         return Py_None;
3295 }
3296
3297 /* void polf2 long s float s[2*arg1] */
3298
3299 static PyObject *
3300 gl_polf2(self, args)
3301         PyObject *self;
3302         PyObject *args;
3303 {
3304         long arg1 ;
3305         float (* arg2) [ 2 ] ;
3306         if (!getilongarraysize(args, 1, 0, &arg1))
3307                 return NULL;
3308         arg1 = arg1 / 2;
3309         if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
3310                 return PyErr_NoMemory();
3311         if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2))
3312                 return NULL;
3313         polf2( arg1 , arg2 );
3314         PyMem_DEL(arg2);
3315         Py_INCREF(Py_None);
3316         return Py_None;
3317 }
3318
3319 /* void poly long s float s[3*arg1] */
3320
3321 static PyObject *
3322 gl_poly(self, args)
3323         PyObject *self;
3324         PyObject *args;
3325 {
3326         long arg1 ;
3327         float (* arg2) [ 3 ] ;
3328         if (!getilongarraysize(args, 1, 0, &arg1))
3329                 return NULL;
3330         arg1 = arg1 / 3;
3331         if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
3332                 return PyErr_NoMemory();
3333         if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
3334                 return NULL;
3335         poly( arg1 , arg2 );
3336         PyMem_DEL(arg2);
3337         Py_INCREF(Py_None);
3338         return Py_None;
3339 }
3340
3341 /* void poly2 long s float s[2*arg1] */
3342
3343 static PyObject *
3344 gl_poly2(self, args)
3345         PyObject *self;
3346         PyObject *args;
3347 {
3348         long arg1 ;
3349         float (* arg2) [ 2 ] ;
3350         if (!getilongarraysize(args, 1, 0, &arg1))
3351                 return NULL;
3352         arg1 = arg1 / 2;
3353         if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
3354                 return PyErr_NoMemory();
3355         if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2))
3356                 return NULL;
3357         poly2( arg1 , arg2 );
3358         PyMem_DEL(arg2);
3359         Py_INCREF(Py_None);
3360         return Py_None;
3361 }
3362
3363 /* void crvn long s float s[3*arg1] */
3364
3365 static PyObject *
3366 gl_crvn(self, args)
3367         PyObject *self;
3368         PyObject *args;
3369 {
3370         long arg1 ;
3371         float (* arg2) [ 3 ] ;
3372         if (!getilongarraysize(args, 1, 0, &arg1))
3373                 return NULL;
3374         arg1 = arg1 / 3;
3375         if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
3376                 return PyErr_NoMemory();
3377         if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
3378                 return NULL;
3379         crvn( arg1 , arg2 );
3380         PyMem_DEL(arg2);
3381         Py_INCREF(Py_None);
3382         return Py_None;
3383 }
3384
3385 /* void rcrvn long s float s[4*arg1] */
3386
3387 static PyObject *
3388 gl_rcrvn(self, args)
3389         PyObject *self;
3390         PyObject *args;
3391 {
3392         long arg1 ;
3393         float (* arg2) [ 4 ] ;
3394         if (!getilongarraysize(args, 1, 0, &arg1))
3395                 return NULL;
3396         arg1 = arg1 / 4;
3397         if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL)
3398                 return PyErr_NoMemory();
3399         if (!getifloatarray(args, 1, 0, 4 * arg1 , (float *) arg2))
3400                 return NULL;
3401         rcrvn( arg1 , arg2 );
3402         PyMem_DEL(arg2);
3403         Py_INCREF(Py_None);
3404         return Py_None;
3405 }
3406
3407 /* void polf2i long s long s[2*arg1] */
3408
3409 static PyObject *
3410 gl_polf2i(self, args)
3411         PyObject *self;
3412         PyObject *args;
3413 {
3414         long arg1 ;
3415         long (* arg2) [ 2 ] ;
3416         if (!getilongarraysize(args, 1, 0, &arg1))
3417                 return NULL;
3418         arg1 = arg1 / 2;
3419         if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
3420                 return PyErr_NoMemory();
3421         if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2))
3422                 return NULL;
3423         polf2i( arg1 , arg2 );
3424         PyMem_DEL(arg2);
3425         Py_INCREF(Py_None);
3426         return Py_None;
3427 }
3428
3429 /* void polfi long s long s[3*arg1] */
3430
3431 static PyObject *
3432 gl_polfi(self, args)
3433         PyObject *self;
3434         PyObject *args;
3435 {
3436         long arg1 ;
3437         long (* arg2) [ 3 ] ;
3438         if (!getilongarraysize(args, 1, 0, &arg1))
3439                 return NULL;
3440         arg1 = arg1 / 3;
3441         if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
3442                 return PyErr_NoMemory();
3443         if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2))
3444                 return NULL;
3445         polfi( arg1 , arg2 );
3446         PyMem_DEL(arg2);
3447         Py_INCREF(Py_None);
3448         return Py_None;
3449 }
3450
3451 /* void poly2i long s long s[2*arg1] */
3452
3453 static PyObject *
3454 gl_poly2i(self, args)
3455         PyObject *self;
3456         PyObject *args;
3457 {
3458         long arg1 ;
3459         long (* arg2) [ 2 ] ;
3460         if (!getilongarraysize(args, 1, 0, &arg1))
3461                 return NULL;
3462         arg1 = arg1 / 2;
3463         if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
3464                 return PyErr_NoMemory();
3465         if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2))
3466                 return NULL;
3467         poly2i( arg1 , arg2 );
3468         PyMem_DEL(arg2);
3469         Py_INCREF(Py_None);
3470         return Py_None;
3471 }
3472
3473 /* void polyi long s long s[3*arg1] */
3474
3475 static PyObject *
3476 gl_polyi(self, args)
3477         PyObject *self;
3478         PyObject *args;
3479 {
3480         long arg1 ;
3481         long (* arg2) [ 3 ] ;
3482         if (!getilongarraysize(args, 1, 0, &arg1))
3483                 return NULL;
3484         arg1 = arg1 / 3;
3485         if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
3486                 return PyErr_NoMemory();
3487         if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2))
3488                 return NULL;
3489         polyi( arg1 , arg2 );
3490         PyMem_DEL(arg2);
3491         Py_INCREF(Py_None);
3492         return Py_None;
3493 }
3494
3495 /* void polf2s long s short s[2*arg1] */
3496
3497 static PyObject *
3498 gl_polf2s(self, args)
3499         PyObject *self;
3500         PyObject *args;
3501 {
3502         long arg1 ;
3503         short (* arg2) [ 2 ] ;
3504         if (!getilongarraysize(args, 1, 0, &arg1))
3505                 return NULL;
3506         arg1 = arg1 / 2;
3507         if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
3508                 return PyErr_NoMemory();
3509         if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2))
3510                 return NULL;
3511         polf2s( arg1 , arg2 );
3512         PyMem_DEL(arg2);
3513         Py_INCREF(Py_None);
3514         return Py_None;
3515 }
3516
3517 /* void polfs long s short s[3*arg1] */
3518
3519 static PyObject *
3520 gl_polfs(self, args)
3521         PyObject *self;
3522         PyObject *args;
3523 {
3524         long arg1 ;
3525         short (* arg2) [ 3 ] ;
3526         if (!getilongarraysize(args, 1, 0, &arg1))
3527                 return NULL;
3528         arg1 = arg1 / 3;
3529         if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
3530                 return PyErr_NoMemory();
3531         if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2))
3532                 return NULL;
3533         polfs( arg1 , arg2 );
3534         PyMem_DEL(arg2);
3535         Py_INCREF(Py_None);
3536         return Py_None;
3537 }
3538
3539 /* void polys long s short s[3*arg1] */
3540
3541 static PyObject *
3542 gl_polys(self, args)
3543         PyObject *self;
3544         PyObject *args;
3545 {
3546         long arg1 ;
3547         short (* arg2) [ 3 ] ;
3548         if (!getilongarraysize(args, 1, 0, &arg1))
3549                 return NULL;
3550         arg1 = arg1 / 3;
3551         if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
3552                 return PyErr_NoMemory();
3553         if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2))
3554                 return NULL;
3555         polys( arg1 , arg2 );
3556         PyMem_DEL(arg2);
3557         Py_INCREF(Py_None);
3558         return Py_None;
3559 }
3560
3561 /* void poly2s long s short s[2*arg1] */
3562
3563 static PyObject *
3564 gl_poly2s(self, args)
3565         PyObject *self;
3566         PyObject *args;
3567 {
3568         long arg1 ;
3569         short (* arg2) [ 2 ] ;
3570         if (!getilongarraysize(args, 1, 0, &arg1))
3571                 return NULL;
3572         arg1 = arg1 / 2;
3573         if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
3574                 return PyErr_NoMemory();
3575         if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2))
3576                 return NULL;
3577         poly2s( arg1 , arg2 );
3578         PyMem_DEL(arg2);
3579         Py_INCREF(Py_None);
3580         return Py_None;
3581 }
3582
3583 /* void defcursor short s u_short s[128] */
3584
3585 static PyObject *
3586 gl_defcursor(self, args)
3587         PyObject *self;
3588         PyObject *args;
3589 {
3590         short arg1 ;
3591         unsigned short arg2 [ 128 ] ;
3592         if (!getishortarg(args, 2, 0, &arg1))
3593                 return NULL;
3594         if (!getishortarray(args, 2, 1, 128 , (short *) arg2))
3595                 return NULL;
3596         defcursor( arg1 , arg2 );
3597         Py_INCREF(Py_None);
3598         return Py_None;
3599 }
3600
3601 /* void writepixels short s u_short s[arg1] */
3602
3603 static PyObject *
3604 gl_writepixels(self, args)
3605         PyObject *self;
3606         PyObject *args;
3607 {
3608         short arg1 ;
3609         unsigned short * arg2 ;
3610         if (!getishortarraysize(args, 1, 0, &arg1))
3611                 return NULL;
3612         if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL)
3613                 return PyErr_NoMemory();
3614         if (!getishortarray(args, 1, 0, arg1 , (short *) arg2))
3615                 return NULL;
3616         writepixels( arg1 , arg2 );
3617         PyMem_DEL(arg2);
3618         Py_INCREF(Py_None);
3619         return Py_None;
3620 }
3621
3622 /* void defbasis long s float s[4*4] */
3623
3624 static PyObject *
3625 gl_defbasis(self, args)
3626         PyObject *self;
3627         PyObject *args;
3628 {
3629         long arg1 ;
3630         float arg2 [ 4 ] [ 4 ] ;
3631         if (!getilongarg(args, 2, 0, &arg1))
3632                 return NULL;
3633         if (!getifloatarray(args, 2, 1, 4 * 4 , (float *) arg2))
3634                 return NULL;
3635         defbasis( arg1 , arg2 );
3636         Py_INCREF(Py_None);
3637         return Py_None;
3638 }
3639
3640 /* void gewrite short s short s[arg1] */
3641
3642 static PyObject *
3643 gl_gewrite(self, args)
3644         PyObject *self;
3645         PyObject *args;
3646 {
3647         short arg1 ;
3648         short * arg2 ;
3649         if (!getishortarraysize(args, 1, 0, &arg1))
3650                 return NULL;
3651         if ((arg2 = PyMem_NEW(short , arg1 )) == NULL)
3652                 return PyErr_NoMemory();
3653         if (!getishortarray(args, 1, 0, arg1 , arg2))
3654                 return NULL;
3655         gewrite( arg1 , arg2 );
3656         PyMem_DEL(arg2);
3657         Py_INCREF(Py_None);
3658         return Py_None;
3659 }
3660
3661 /* void rotate short s char s */
3662
3663 static PyObject *
3664 gl_rotate(self, args)
3665         PyObject *self;
3666         PyObject *args;
3667 {
3668         short arg1 ;
3669         char arg2 ;
3670         if (!getishortarg(args, 2, 0, &arg1))
3671                 return NULL;
3672         if (!getichararg(args, 2, 1, &arg2))
3673                 return NULL;
3674         rotate( arg1 , arg2 );
3675         Py_INCREF(Py_None);
3676         return Py_None;
3677 }
3678
3679 /* void rot float s char s */
3680
3681 static PyObject *
3682 gl_rot(self, args)
3683         PyObject *self;
3684         PyObject *args;
3685 {
3686         float arg1 ;
3687         char arg2 ;
3688         if (!getifloatarg(args, 2, 0, &arg1))
3689                 return NULL;
3690         if (!getichararg(args, 2, 1, &arg2))
3691                 return NULL;
3692         rot( arg1 , arg2 );
3693         Py_INCREF(Py_None);
3694         return Py_None;
3695 }
3696
3697 /* void circfi long s long s long s */
3698
3699 static PyObject *
3700 gl_circfi(self, args)
3701         PyObject *self;
3702         PyObject *args;
3703 {
3704         long arg1 ;
3705         long arg2 ;
3706         long arg3 ;
3707         if (!getilongarg(args, 3, 0, &arg1))
3708                 return NULL;
3709         if (!getilongarg(args, 3, 1, &arg2))
3710                 return NULL;
3711         if (!getilongarg(args, 3, 2, &arg3))
3712                 return NULL;
3713         circfi( arg1 , arg2 , arg3 );
3714         Py_INCREF(Py_None);
3715         return Py_None;
3716 }
3717
3718 /* void circi long s long s long s */
3719
3720 static PyObject *
3721 gl_circi(self, args)
3722         PyObject *self;
3723         PyObject *args;
3724 {
3725         long arg1 ;
3726         long arg2 ;
3727         long arg3 ;
3728         if (!getilongarg(args, 3, 0, &arg1))
3729                 return NULL;
3730         if (!getilongarg(args, 3, 1, &arg2))
3731                 return NULL;
3732         if (!getilongarg(args, 3, 2, &arg3))
3733                 return NULL;
3734         circi( arg1 , arg2 , arg3 );
3735         Py_INCREF(Py_None);
3736         return Py_None;
3737 }
3738
3739 /* void cmovi long s long s long s */
3740
3741 static PyObject *
3742 gl_cmovi(self, args)
3743         PyObject *self;
3744         PyObject *args;
3745 {
3746         long arg1 ;
3747         long arg2 ;
3748         long arg3 ;
3749         if (!getilongarg(args, 3, 0, &arg1))
3750                 return NULL;
3751         if (!getilongarg(args, 3, 1, &arg2))
3752                 return NULL;
3753         if (!getilongarg(args, 3, 2, &arg3))
3754                 return NULL;
3755         cmovi( arg1 , arg2 , arg3 );
3756         Py_INCREF(Py_None);
3757         return Py_None;
3758 }
3759
3760 /* void drawi long s long s long s */
3761
3762 static PyObject *
3763 gl_drawi(self, args)
3764         PyObject *self;
3765         PyObject *args;
3766 {
3767         long arg1 ;
3768         long arg2 ;
3769         long arg3 ;
3770         if (!getilongarg(args, 3, 0, &arg1))
3771                 return NULL;
3772         if (!getilongarg(args, 3, 1, &arg2))
3773                 return NULL;
3774         if (!getilongarg(args, 3, 2, &arg3))
3775                 return NULL;
3776         drawi( arg1 , arg2 , arg3 );
3777         Py_INCREF(Py_None);
3778         return Py_None;
3779 }
3780
3781 /* void movei long s long s long s */
3782
3783 static PyObject *
3784 gl_movei(self, args)
3785         PyObject *self;
3786         PyObject *args;
3787 {
3788         long arg1 ;
3789         long arg2 ;
3790         long arg3 ;
3791         if (!getilongarg(args, 3, 0, &arg1))
3792                 return NULL;
3793         if (!getilongarg(args, 3, 1, &arg2))
3794                 return NULL;
3795         if (!getilongarg(args, 3, 2, &arg3))
3796                 return NULL;
3797         movei( arg1 , arg2 , arg3 );
3798         Py_INCREF(Py_None);
3799         return Py_None;
3800 }
3801
3802 /* void pnti long s long s long s */
3803
3804 static PyObject *
3805 gl_pnti(self, args)
3806         PyObject *self;
3807         PyObject *args;
3808 {
3809         long arg1 ;
3810         long arg2 ;
3811         long arg3 ;
3812         if (!getilongarg(args, 3, 0, &arg1))
3813                 return NULL;
3814         if (!getilongarg(args, 3, 1, &arg2))
3815                 return NULL;
3816         if (!getilongarg(args, 3, 2, &arg3))
3817                 return NULL;
3818         pnti( arg1 , arg2 , arg3 );
3819         Py_INCREF(Py_None);
3820         return Py_None;
3821 }
3822
3823 /* void newtag long s long s long s */
3824
3825 static PyObject *
3826 gl_newtag(self, args)
3827         PyObject *self;
3828         PyObject *args;
3829 {
3830         long arg1 ;
3831         long arg2 ;
3832         long arg3 ;
3833         if (!getilongarg(args, 3, 0, &arg1))
3834                 return NULL;
3835         if (!getilongarg(args, 3, 1, &arg2))
3836                 return NULL;
3837         if (!getilongarg(args, 3, 2, &arg3))
3838                 return NULL;
3839         newtag( arg1 , arg2 , arg3 );
3840         Py_INCREF(Py_None);
3841         return Py_None;
3842 }
3843
3844 /* void pdri long s long s long s */
3845
3846 static PyObject *
3847 gl_pdri(self, args)
3848         PyObject *self;
3849         PyObject *args;
3850 {
3851         long arg1 ;
3852         long arg2 ;
3853         long arg3 ;
3854         if (!getilongarg(args, 3, 0, &arg1))
3855                 return NULL;
3856         if (!getilongarg(args, 3, 1, &arg2))
3857                 return NULL;
3858         if (!getilongarg(args, 3, 2, &arg3))
3859                 return NULL;
3860         pdri( arg1 , arg2 , arg3 );
3861         Py_INCREF(Py_None);
3862         return Py_None;
3863 }
3864
3865 /* void pmvi long s long s long s */
3866
3867 static PyObject *
3868 gl_pmvi(self, args)
3869         PyObject *self;
3870         PyObject *args;
3871 {
3872         long arg1 ;
3873         long arg2 ;
3874         long arg3 ;
3875         if (!getilongarg(args, 3, 0, &arg1))
3876                 return NULL;
3877         if (!getilongarg(args, 3, 1, &arg2))
3878                 return NULL;
3879         if (!getilongarg(args, 3, 2, &arg3))
3880                 return NULL;
3881         pmvi( arg1 , arg2 , arg3 );
3882         Py_INCREF(Py_None);
3883         return Py_None;
3884 }
3885
3886 /* void rdri long s long s long s */
3887
3888 static PyObject *
3889 gl_rdri(self, args)
3890         PyObject *self;
3891         PyObject *args;
3892 {
3893         long arg1 ;
3894         long arg2 ;
3895         long arg3 ;
3896         if (!getilongarg(args, 3, 0, &arg1))
3897                 return NULL;
3898         if (!getilongarg(args, 3, 1, &arg2))
3899                 return NULL;
3900         if (!getilongarg(args, 3, 2, &arg3))
3901                 return NULL;
3902         rdri( arg1 , arg2 , arg3 );
3903         Py_INCREF(Py_None);
3904         return Py_None;
3905 }
3906
3907 /* void rmvi long s long s long s */
3908
3909 static PyObject *
3910 gl_rmvi(self, args)
3911         PyObject *self;
3912         PyObject *args;
3913 {
3914         long arg1 ;
3915         long arg2 ;
3916         long arg3 ;
3917         if (!getilongarg(args, 3, 0, &arg1))
3918                 return NULL;
3919         if (!getilongarg(args, 3, 1, &arg2))
3920                 return NULL;
3921         if (!getilongarg(args, 3, 2, &arg3))
3922                 return NULL;
3923         rmvi( arg1 , arg2 , arg3 );
3924         Py_INCREF(Py_None);
3925         return Py_None;
3926 }
3927
3928 /* void rpdri long s long s long s */
3929
3930 static PyObject *
3931 gl_rpdri(self, args)
3932         PyObject *self;
3933         PyObject *args;
3934 {
3935         long arg1 ;
3936         long arg2 ;
3937         long arg3 ;
3938         if (!getilongarg(args, 3, 0, &arg1))
3939                 return NULL;
3940         if (!getilongarg(args, 3, 1, &arg2))
3941                 return NULL;
3942         if (!getilongarg(args, 3, 2, &arg3))
3943                 return NULL;
3944         rpdri( arg1 , arg2 , arg3 );
3945         Py_INCREF(Py_None);
3946         return Py_None;
3947 }
3948
3949 /* void rpmvi long s long s long s */
3950
3951 static PyObject *
3952 gl_rpmvi(self, args)
3953         PyObject *self;
3954         PyObject *args;
3955 {
3956         long arg1 ;
3957         long arg2 ;
3958         long arg3 ;
3959         if (!getilongarg(args, 3, 0, &arg1))
3960                 return NULL;
3961         if (!getilongarg(args, 3, 1, &arg2))
3962                 return NULL;
3963         if (!getilongarg(args, 3, 2, &arg3))
3964                 return NULL;
3965         rpmvi( arg1 , arg2 , arg3 );
3966         Py_INCREF(Py_None);
3967         return Py_None;
3968 }
3969
3970 /* void xfpti long s long s long s */
3971
3972 static PyObject *
3973 gl_xfpti(self, args)
3974         PyObject *self;
3975         PyObject *args;
3976 {
3977         long arg1 ;
3978         long arg2 ;
3979         long arg3 ;
3980         if (!getilongarg(args, 3, 0, &arg1))
3981                 return NULL;
3982         if (!getilongarg(args, 3, 1, &arg2))
3983                 return NULL;
3984         if (!getilongarg(args, 3, 2, &arg3))
3985                 return NULL;
3986         xfpti( arg1 , arg2 , arg3 );
3987         Py_INCREF(Py_None);
3988         return Py_None;
3989 }
3990
3991 /* void circ float s float s float s */
3992
3993 static PyObject *
3994 gl_circ(self, args)
3995         PyObject *self;
3996         PyObject *args;
3997 {
3998         float arg1 ;
3999         float arg2 ;
4000         float arg3 ;
4001         if (!getifloatarg(args, 3, 0, &arg1))
4002                 return NULL;
4003         if (!getifloatarg(args, 3, 1, &arg2))
4004                 return NULL;
4005         if (!getifloatarg(args, 3, 2, &arg3))
4006                 return NULL;
4007         circ( arg1 , arg2 , arg3 );
4008         Py_INCREF(Py_None);
4009         return Py_None;
4010 }
4011
4012 /* void circf float s float s float s */
4013
4014 static PyObject *
4015 gl_circf(self, args)
4016         PyObject *self;
4017         PyObject *args;
4018 {
4019         float arg1 ;
4020         float arg2 ;
4021         float arg3 ;
4022         if (!getifloatarg(args, 3, 0, &arg1))
4023                 return NULL;
4024         if (!getifloatarg(args, 3, 1, &arg2))
4025                 return NULL;
4026         if (!getifloatarg(args, 3, 2, &arg3))
4027                 return NULL;
4028         circf( arg1 , arg2 , arg3 );
4029         Py_INCREF(Py_None);
4030         return Py_None;
4031 }
4032
4033 /* void cmov float s float s float s */
4034
4035 static PyObject *
4036 gl_cmov(self, args)
4037         PyObject *self;
4038         PyObject *args;
4039 {
4040         float arg1 ;
4041         float arg2 ;
4042         float arg3 ;
4043         if (!getifloatarg(args, 3, 0, &arg1))
4044                 return NULL;
4045         if (!getifloatarg(args, 3, 1, &arg2))
4046                 return NULL;
4047         if (!getifloatarg(args, 3, 2, &arg3))
4048                 return NULL;
4049         cmov( arg1 , arg2 , arg3 );
4050         Py_INCREF(Py_None);
4051         return Py_None;
4052 }
4053
4054 /* void draw float s float s float s */
4055
4056 static PyObject *
4057 gl_draw(self, args)
4058         PyObject *self;
4059         PyObject *args;
4060 {
4061         float arg1 ;
4062         float arg2 ;
4063         float arg3 ;
4064         if (!getifloatarg(args, 3, 0, &arg1))
4065                 return NULL;
4066         if (!getifloatarg(args, 3, 1, &arg2))
4067                 return NULL;
4068         if (!getifloatarg(args, 3, 2, &arg3))
4069                 return NULL;
4070         draw( arg1 , arg2 , arg3 );
4071         Py_INCREF(Py_None);
4072         return Py_None;
4073 }
4074
4075 /* void move float s float s float s */
4076
4077 static PyObject *
4078 gl_move(self, args)
4079         PyObject *self;
4080         PyObject *args;
4081 {
4082         float arg1 ;
4083         float arg2 ;
4084         float arg3 ;
4085         if (!getifloatarg(args, 3, 0, &arg1))
4086                 return NULL;
4087         if (!getifloatarg(args, 3, 1, &arg2))
4088                 return NULL;
4089         if (!getifloatarg(args, 3, 2, &arg3))
4090                 return NULL;
4091         move( arg1 , arg2 , arg3 );
4092         Py_INCREF(Py_None);
4093         return Py_None;
4094 }
4095
4096 /* void pnt float s float s float s */
4097
4098 static PyObject *
4099 gl_pnt(self, args)
4100         PyObject *self;
4101         PyObject *args;
4102 {
4103         float arg1 ;
4104         float arg2 ;
4105         float arg3 ;
4106         if (!getifloatarg(args, 3, 0, &arg1))
4107                 return NULL;
4108         if (!getifloatarg(args, 3, 1, &arg2))
4109                 return NULL;
4110         if (!getifloatarg(args, 3, 2, &arg3))
4111                 return NULL;
4112         pnt( arg1 , arg2 , arg3 );
4113         Py_INCREF(Py_None);
4114         return Py_None;
4115 }
4116
4117 /* void scale float s float s float s */
4118
4119 static PyObject *
4120 gl_scale(self, args)
4121         PyObject *self;
4122         PyObject *args;
4123 {
4124         float arg1 ;
4125         float arg2 ;
4126         float arg3 ;
4127         if (!getifloatarg(args, 3, 0, &arg1))
4128                 return NULL;
4129         if (!getifloatarg(args, 3, 1, &arg2))
4130                 return NULL;
4131         if (!getifloatarg(args, 3, 2, &arg3))
4132                 return NULL;
4133         scale( arg1 , arg2 , arg3 );
4134         Py_INCREF(Py_None);
4135         return Py_None;
4136 }
4137
4138 /* void translate float s float s float s */
4139
4140 static PyObject *
4141 gl_translate(self, args)
4142         PyObject *self;
4143         PyObject *args;
4144 {
4145         float arg1 ;
4146         float arg2 ;
4147         float arg3 ;
4148         if (!getifloatarg(args, 3, 0, &arg1))
4149                 return NULL;
4150         if (!getifloatarg(args, 3, 1, &arg2))
4151                 return NULL;
4152         if (!getifloatarg(args, 3, 2, &arg3))
4153                 return NULL;
4154         translate( arg1 , arg2 , arg3 );
4155         Py_INCREF(Py_None);
4156         return Py_None;
4157 }
4158
4159 /* void pdr float s float s float s */
4160
4161 static PyObject *
4162 gl_pdr(self, args)
4163         PyObject *self;
4164         PyObject *args;
4165 {
4166         float arg1 ;
4167         float arg2 ;
4168         float arg3 ;
4169         if (!getifloatarg(args, 3, 0, &arg1))
4170                 return NULL;
4171         if (!getifloatarg(args, 3, 1, &arg2))
4172                 return NULL;
4173         if (!getifloatarg(args, 3, 2, &arg3))
4174                 return NULL;
4175         pdr( arg1 , arg2 , arg3 );
4176         Py_INCREF(Py_None);
4177         return Py_None;
4178 }
4179
4180 /* void pmv float s float s float s */
4181
4182 static PyObject *
4183 gl_pmv(self, args)
4184         PyObject *self;
4185         PyObject *args;
4186 {
4187         float arg1 ;
4188         float arg2 ;
4189         float arg3 ;
4190         if (!getifloatarg(args, 3, 0, &arg1))
4191                 return NULL;
4192         if (!getifloatarg(args, 3, 1, &arg2))
4193                 return NULL;
4194         if (!getifloatarg(args, 3, 2, &arg3))
4195                 return NULL;
4196         pmv( arg1 , arg2 , arg3 );
4197         Py_INCREF(Py_None);
4198         return Py_None;
4199 }
4200
4201 /* void rdr float s float s float s */
4202
4203 static PyObject *
4204 gl_rdr(self, args)
4205         PyObject *self;
4206         PyObject *args;
4207 {
4208         float arg1 ;
4209         float arg2 ;
4210         float arg3 ;
4211         if (!getifloatarg(args, 3, 0, &arg1))
4212                 return NULL;
4213         if (!getifloatarg(args, 3, 1, &arg2))
4214                 return NULL;
4215         if (!getifloatarg(args, 3, 2, &arg3))
4216                 return NULL;
4217         rdr( arg1 , arg2 , arg3 );
4218         Py_INCREF(Py_None);
4219         return Py_None;
4220 }
4221
4222 /* void rmv float s float s float s */
4223
4224 static PyObject *
4225 gl_rmv(self, args)
4226         PyObject *self;
4227         PyObject *args;
4228 {
4229         float arg1 ;
4230         float arg2 ;
4231         float arg3 ;
4232         if (!getifloatarg(args, 3, 0, &arg1))
4233                 return NULL;
4234         if (!getifloatarg(args, 3, 1, &arg2))
4235                 return NULL;
4236         if (!getifloatarg(args, 3, 2, &arg3))
4237                 return NULL;
4238         rmv( arg1 , arg2 , arg3 );
4239         Py_INCREF(Py_None);
4240         return Py_None;
4241 }
4242
4243 /* void rpdr float s float s float s */
4244
4245 static PyObject *
4246 gl_rpdr(self, args)
4247         PyObject *self;
4248         PyObject *args;
4249 {
4250         float arg1 ;
4251         float arg2 ;
4252         float arg3 ;
4253         if (!getifloatarg(args, 3, 0, &arg1))
4254                 return NULL;
4255         if (!getifloatarg(args, 3, 1, &arg2))
4256                 return NULL;
4257         if (!getifloatarg(args, 3, 2, &arg3))
4258                 return NULL;
4259         rpdr( arg1 , arg2 , arg3 );
4260         Py_INCREF(Py_None);
4261         return Py_None;
4262 }
4263
4264 /* void rpmv float s float s float s */
4265
4266 static PyObject *
4267 gl_rpmv(self, args)
4268         PyObject *self;
4269         PyObject *args;
4270 {
4271         float arg1 ;
4272         float arg2 ;
4273         float arg3 ;
4274         if (!getifloatarg(args, 3, 0, &arg1))
4275                 return NULL;
4276         if (!getifloatarg(args, 3, 1, &arg2))
4277                 return NULL;
4278         if (!getifloatarg(args, 3, 2, &arg3))
4279                 return NULL;
4280         rpmv( arg1 , arg2 , arg3 );
4281         Py_INCREF(Py_None);
4282         return Py_None;
4283 }
4284
4285 /* void xfpt float s float s float s */
4286
4287 static PyObject *
4288 gl_xfpt(self, args)
4289         PyObject *self;
4290         PyObject *args;
4291 {
4292         float arg1 ;
4293         float arg2 ;
4294         float arg3 ;
4295         if (!getifloatarg(args, 3, 0, &arg1))
4296                 return NULL;
4297         if (!getifloatarg(args, 3, 1, &arg2))
4298                 return NULL;
4299         if (!getifloatarg(args, 3, 2, &arg3))
4300                 return NULL;
4301         xfpt( arg1 , arg2 , arg3 );
4302         Py_INCREF(Py_None);
4303         return Py_None;
4304 }
4305
4306 /* void RGBcolor short s short s short s */
4307
4308 static PyObject *
4309 gl_RGBcolor(self, args)
4310         PyObject *self;
4311         PyObject *args;
4312 {
4313         short arg1 ;
4314         short arg2 ;
4315         short arg3 ;
4316         if (!getishortarg(args, 3, 0, &arg1))
4317                 return NULL;
4318         if (!getishortarg(args, 3, 1, &arg2))
4319                 return NULL;
4320         if (!getishortarg(args, 3, 2, &arg3))
4321                 return NULL;
4322         RGBcolor( arg1 , arg2 , arg3 );
4323         Py_INCREF(Py_None);
4324         return Py_None;
4325 }
4326
4327 /* void RGBwritemask short s short s short s */
4328
4329 static PyObject *
4330 gl_RGBwritemask(self, args)
4331         PyObject *self;
4332         PyObject *args;
4333 {
4334         short arg1 ;
4335         short arg2 ;
4336         short arg3 ;
4337         if (!getishortarg(args, 3, 0, &arg1))
4338                 return NULL;
4339         if (!getishortarg(args, 3, 1, &arg2))
4340                 return NULL;
4341         if (!getishortarg(args, 3, 2, &arg3))
4342                 return NULL;
4343         RGBwritemask( arg1 , arg2 , arg3 );
4344         Py_INCREF(Py_None);
4345         return Py_None;
4346 }
4347
4348 /* void setcursor short s short s short s */
4349
4350 static PyObject *
4351 gl_setcursor(self, args)
4352         PyObject *self;
4353         PyObject *args;
4354 {
4355         short arg1 ;
4356         short arg2 ;
4357         short arg3 ;
4358         if (!getishortarg(args, 3, 0, &arg1))
4359                 return NULL;
4360         if (!getishortarg(args, 3, 1, &arg2))
4361                 return NULL;
4362         if (!getishortarg(args, 3, 2, &arg3))
4363                 return NULL;
4364         setcursor( arg1 , arg2 , arg3 );
4365         Py_INCREF(Py_None);
4366         return Py_None;
4367 }
4368
4369 /* void tie short s short s short s */
4370
4371 static PyObject *
4372 gl_tie(self, args)
4373         PyObject *self;
4374         PyObject *args;
4375 {
4376         short arg1 ;
4377         short arg2 ;
4378         short arg3 ;
4379         if (!getishortarg(args, 3, 0, &arg1))
4380                 return NULL;
4381         if (!getishortarg(args, 3, 1, &arg2))
4382                 return NULL;
4383         if (!getishortarg(args, 3, 2, &arg3))
4384                 return NULL;
4385         tie( arg1 , arg2 , arg3 );
4386         Py_INCREF(Py_None);
4387         return Py_None;
4388 }
4389
4390 /* void circfs short s short s short s */
4391
4392 static PyObject *
4393 gl_circfs(self, args)
4394         PyObject *self;
4395         PyObject *args;
4396 {
4397         short arg1 ;
4398         short arg2 ;
4399         short arg3 ;
4400         if (!getishortarg(args, 3, 0, &arg1))
4401                 return NULL;
4402         if (!getishortarg(args, 3, 1, &arg2))
4403                 return NULL;
4404         if (!getishortarg(args, 3, 2, &arg3))
4405                 return NULL;
4406         circfs( arg1 , arg2 , arg3 );
4407         Py_INCREF(Py_None);
4408         return Py_None;
4409 }
4410
4411 /* void circs short s short s short s */
4412
4413 static PyObject *
4414 gl_circs(self, args)
4415         PyObject *self;
4416         PyObject *args;
4417 {
4418         short arg1 ;
4419         short arg2 ;
4420         short arg3 ;
4421         if (!getishortarg(args, 3, 0, &arg1))
4422                 return NULL;
4423         if (!getishortarg(args, 3, 1, &arg2))
4424                 return NULL;
4425         if (!getishortarg(args, 3, 2, &arg3))
4426                 return NULL;
4427         circs( arg1 , arg2 , arg3 );
4428         Py_INCREF(Py_None);
4429         return Py_None;
4430 }
4431
4432 /* void cmovs short s short s short s */
4433
4434 static PyObject *
4435 gl_cmovs(self, args)
4436         PyObject *self;
4437         PyObject *args;
4438 {
4439         short arg1 ;
4440         short arg2 ;
4441         short arg3 ;
4442         if (!getishortarg(args, 3, 0, &arg1))
4443                 return NULL;
4444         if (!getishortarg(args, 3, 1, &arg2))
4445                 return NULL;
4446         if (!getishortarg(args, 3, 2, &arg3))
4447                 return NULL;
4448         cmovs( arg1 , arg2 , arg3 );
4449         Py_INCREF(Py_None);
4450         return Py_None;
4451 }
4452
4453 /* void draws short s short s short s */
4454
4455 static PyObject *
4456 gl_draws(self, args)
4457         PyObject *self;
4458         PyObject *args;
4459 {
4460         short arg1 ;
4461         short arg2 ;
4462         short arg3 ;
4463         if (!getishortarg(args, 3, 0, &arg1))
4464                 return NULL;
4465         if (!getishortarg(args, 3, 1, &arg2))
4466                 return NULL;
4467         if (!getishortarg(args, 3, 2, &arg3))
4468                 return NULL;
4469         draws( arg1 , arg2 , arg3 );
4470         Py_INCREF(Py_None);
4471         return Py_None;
4472 }
4473
4474 /* void moves short s short s short s */
4475
4476 static PyObject *
4477 gl_moves(self, args)
4478         PyObject *self;
4479         PyObject *args;
4480 {
4481         short arg1 ;
4482         short arg2 ;
4483         short arg3 ;
4484         if (!getishortarg(args, 3, 0, &arg1))
4485                 return NULL;
4486         if (!getishortarg(args, 3, 1, &arg2))
4487                 return NULL;
4488         if (!getishortarg(args, 3, 2, &arg3))
4489                 return NULL;
4490         moves( arg1 , arg2 , arg3 );
4491         Py_INCREF(Py_None);
4492         return Py_None;
4493 }
4494
4495 /* void pdrs short s short s short s */
4496
4497 static PyObject *
4498 gl_pdrs(self, args)
4499         PyObject *self;
4500         PyObject *args;
4501 {
4502         short arg1 ;
4503         short arg2 ;
4504         short arg3 ;
4505         if (!getishortarg(args, 3, 0, &arg1))
4506                 return NULL;
4507         if (!getishortarg(args, 3, 1, &arg2))
4508                 return NULL;
4509         if (!getishortarg(args, 3, 2, &arg3))
4510                 return NULL;
4511         pdrs( arg1 , arg2 , arg3 );
4512         Py_INCREF(Py_None);
4513         return Py_None;
4514 }
4515
4516 /* void pmvs short s short s short s */
4517
4518 static PyObject *
4519 gl_pmvs(self, args)
4520         PyObject *self;
4521         PyObject *args;
4522 {
4523         short arg1 ;
4524         short arg2 ;
4525         short arg3 ;
4526         if (!getishortarg(args, 3, 0, &arg1))
4527                 return NULL;
4528         if (!getishortarg(args, 3, 1, &arg2))
4529                 return NULL;
4530         if (!getishortarg(args, 3, 2, &arg3))
4531                 return NULL;
4532         pmvs( arg1 , arg2 , arg3 );
4533         Py_INCREF(Py_None);
4534         return Py_None;
4535 }
4536
4537 /* void pnts short s short s short s */
4538
4539 static PyObject *
4540 gl_pnts(self, args)
4541         PyObject *self;
4542         PyObject *args;
4543 {
4544         short arg1 ;
4545         short arg2 ;
4546         short arg3 ;
4547         if (!getishortarg(args, 3, 0, &arg1))
4548                 return NULL;
4549         if (!getishortarg(args, 3, 1, &arg2))
4550                 return NULL;
4551         if (!getishortarg(args, 3, 2, &arg3))
4552                 return NULL;
4553         pnts( arg1 , arg2 , arg3 );
4554         Py_INCREF(Py_None);
4555         return Py_None;
4556 }
4557
4558 /* void rdrs short s short s short s */
4559
4560 static PyObject *
4561 gl_rdrs(self, args)
4562         PyObject *self;
4563         PyObject *args;
4564 {
4565         short arg1 ;
4566         short arg2 ;
4567         short arg3 ;
4568         if (!getishortarg(args, 3, 0, &arg1))
4569                 return NULL;
4570         if (!getishortarg(args, 3, 1, &arg2))
4571                 return NULL;
4572         if (!getishortarg(args, 3, 2, &arg3))
4573                 return NULL;
4574         rdrs( arg1 , arg2 , arg3 );
4575         Py_INCREF(Py_None);
4576         return Py_None;
4577 }
4578
4579 /* void rmvs short s short s short s */
4580
4581 static PyObject *
4582 gl_rmvs(self, args)
4583         PyObject *self;
4584         PyObject *args;
4585 {
4586         short arg1 ;
4587         short arg2 ;
4588         short arg3 ;
4589         if (!getishortarg(args, 3, 0, &arg1))
4590                 return NULL;
4591         if (!getishortarg(args, 3, 1, &arg2))
4592                 return NULL;
4593         if (!getishortarg(args, 3, 2, &arg3))
4594                 return NULL;
4595         rmvs( arg1 , arg2 , arg3 );
4596         Py_INCREF(Py_None);
4597         return Py_None;
4598 }
4599
4600 /* void rpdrs short s short s short s */
4601
4602 static PyObject *
4603 gl_rpdrs(self, args)
4604         PyObject *self;
4605         PyObject *args;
4606 {
4607         short arg1 ;
4608         short arg2 ;
4609         short arg3 ;
4610         if (!getishortarg(args, 3, 0, &arg1))
4611                 return NULL;
4612         if (!getishortarg(args, 3, 1, &arg2))
4613                 return NULL;
4614         if (!getishortarg(args, 3, 2, &arg3))
4615                 return NULL;
4616         rpdrs( arg1 , arg2 , arg3 );
4617         Py_INCREF(Py_None);
4618         return Py_None;
4619 }
4620
4621 /* void rpmvs short s short s short s */
4622
4623 static PyObject *
4624 gl_rpmvs(self, args)
4625         PyObject *self;
4626         PyObject *args;
4627 {
4628         short arg1 ;
4629         short arg2 ;
4630         short arg3 ;
4631         if (!getishortarg(args, 3, 0, &arg1))
4632                 return NULL;
4633         if (!getishortarg(args, 3, 1, &arg2))
4634                 return NULL;
4635         if (!getishortarg(args, 3, 2, &arg3))
4636                 return NULL;
4637         rpmvs( arg1 , arg2 , arg3 );
4638         Py_INCREF(Py_None);
4639         return Py_None;
4640 }
4641
4642 /* void xfpts short s short s short s */
4643
4644 static PyObject *
4645 gl_xfpts(self, args)
4646         PyObject *self;
4647         PyObject *args;
4648 {
4649         short arg1 ;
4650         short arg2 ;
4651         short arg3 ;
4652         if (!getishortarg(args, 3, 0, &arg1))
4653                 return NULL;
4654         if (!getishortarg(args, 3, 1, &arg2))
4655                 return NULL;
4656         if (!getishortarg(args, 3, 2, &arg3))
4657                 return NULL;
4658         xfpts( arg1 , arg2 , arg3 );
4659         Py_INCREF(Py_None);
4660         return Py_None;
4661 }
4662
4663 /* void curorigin short s short s short s */
4664
4665 static PyObject *
4666 gl_curorigin(self, args)
4667         PyObject *self;
4668         PyObject *args;
4669 {
4670         short arg1 ;
4671         short arg2 ;
4672         short arg3 ;
4673         if (!getishortarg(args, 3, 0, &arg1))
4674                 return NULL;
4675         if (!getishortarg(args, 3, 1, &arg2))
4676                 return NULL;
4677         if (!getishortarg(args, 3, 2, &arg3))
4678                 return NULL;
4679         curorigin( arg1 , arg2 , arg3 );
4680         Py_INCREF(Py_None);
4681         return Py_None;
4682 }
4683
4684 /* void cyclemap short s short s short s */
4685
4686 static PyObject *
4687 gl_cyclemap(self, args)
4688         PyObject *self;
4689         PyObject *args;
4690 {
4691         short arg1 ;
4692         short arg2 ;
4693         short arg3 ;
4694         if (!getishortarg(args, 3, 0, &arg1))
4695                 return NULL;
4696         if (!getishortarg(args, 3, 1, &arg2))
4697                 return NULL;
4698         if (!getishortarg(args, 3, 2, &arg3))
4699                 return NULL;
4700         cyclemap( arg1 , arg2 , arg3 );
4701         Py_INCREF(Py_None);
4702         return Py_None;
4703 }
4704
4705 /* void patch float s[4*4] float s[4*4] float s[4*4] */
4706
4707 static PyObject *
4708 gl_patch(self, args)
4709         PyObject *self;
4710         PyObject *args;
4711 {
4712         float arg1 [ 4 ] [ 4 ] ;
4713         float arg2 [ 4 ] [ 4 ] ;
4714         float arg3 [ 4 ] [ 4 ] ;
4715         if (!getifloatarray(args, 3, 0, 4 * 4 , (float *) arg1))
4716                 return NULL;
4717         if (!getifloatarray(args, 3, 1, 4 * 4 , (float *) arg2))
4718                 return NULL;
4719         if (!getifloatarray(args, 3, 2, 4 * 4 , (float *) arg3))
4720                 return NULL;
4721         patch( arg1 , arg2 , arg3 );
4722         Py_INCREF(Py_None);
4723         return Py_None;
4724 }
4725
4726 /* void splf long s float s[3*arg1] u_short s[arg1] */
4727
4728 static PyObject *
4729 gl_splf(self, args)
4730         PyObject *self;
4731         PyObject *args;
4732 {
4733         long arg1 ;
4734         float (* arg2) [ 3 ] ;
4735         unsigned short * arg3 ;
4736         if (!getilongarraysize(args, 2, 0, &arg1))
4737                 return NULL;
4738         arg1 = arg1 / 3;
4739         if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
4740                 return PyErr_NoMemory();
4741         if (!getifloatarray(args, 2, 0, 3 * arg1 , (float *) arg2))
4742                 return NULL;
4743         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4744                 return PyErr_NoMemory();
4745         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4746                 return NULL;
4747         splf( arg1 , arg2 , arg3 );
4748         PyMem_DEL(arg2);
4749         PyMem_DEL(arg3);
4750         Py_INCREF(Py_None);
4751         return Py_None;
4752 }
4753
4754 /* void splf2 long s float s[2*arg1] u_short s[arg1] */
4755
4756 static PyObject *
4757 gl_splf2(self, args)
4758         PyObject *self;
4759         PyObject *args;
4760 {
4761         long arg1 ;
4762         float (* arg2) [ 2 ] ;
4763         unsigned short * arg3 ;
4764         if (!getilongarraysize(args, 2, 0, &arg1))
4765                 return NULL;
4766         arg1 = arg1 / 2;
4767         if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
4768                 return PyErr_NoMemory();
4769         if (!getifloatarray(args, 2, 0, 2 * arg1 , (float *) arg2))
4770                 return NULL;
4771         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4772                 return PyErr_NoMemory();
4773         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4774                 return NULL;
4775         splf2( arg1 , arg2 , arg3 );
4776         PyMem_DEL(arg2);
4777         PyMem_DEL(arg3);
4778         Py_INCREF(Py_None);
4779         return Py_None;
4780 }
4781
4782 /* void splfi long s long s[3*arg1] u_short s[arg1] */
4783
4784 static PyObject *
4785 gl_splfi(self, args)
4786         PyObject *self;
4787         PyObject *args;
4788 {
4789         long arg1 ;
4790         long (* arg2) [ 3 ] ;
4791         unsigned short * arg3 ;
4792         if (!getilongarraysize(args, 2, 0, &arg1))
4793                 return NULL;
4794         arg1 = arg1 / 3;
4795         if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
4796                 return PyErr_NoMemory();
4797         if (!getilongarray(args, 2, 0, 3 * arg1 , (long *) arg2))
4798                 return NULL;
4799         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4800                 return PyErr_NoMemory();
4801         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4802                 return NULL;
4803         splfi( arg1 , arg2 , arg3 );
4804         PyMem_DEL(arg2);
4805         PyMem_DEL(arg3);
4806         Py_INCREF(Py_None);
4807         return Py_None;
4808 }
4809
4810 /* void splf2i long s long s[2*arg1] u_short s[arg1] */
4811
4812 static PyObject *
4813 gl_splf2i(self, args)
4814         PyObject *self;
4815         PyObject *args;
4816 {
4817         long arg1 ;
4818         long (* arg2) [ 2 ] ;
4819         unsigned short * arg3 ;
4820         if (!getilongarraysize(args, 2, 0, &arg1))
4821                 return NULL;
4822         arg1 = arg1 / 2;
4823         if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
4824                 return PyErr_NoMemory();
4825         if (!getilongarray(args, 2, 0, 2 * arg1 , (long *) arg2))
4826                 return NULL;
4827         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4828                 return PyErr_NoMemory();
4829         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4830                 return NULL;
4831         splf2i( arg1 , arg2 , arg3 );
4832         PyMem_DEL(arg2);
4833         PyMem_DEL(arg3);
4834         Py_INCREF(Py_None);
4835         return Py_None;
4836 }
4837
4838 /* void splfs long s short s[3*arg1] u_short s[arg1] */
4839
4840 static PyObject *
4841 gl_splfs(self, args)
4842         PyObject *self;
4843         PyObject *args;
4844 {
4845         long arg1 ;
4846         short (* arg2) [ 3 ] ;
4847         unsigned short * arg3 ;
4848         if (!getilongarraysize(args, 2, 0, &arg1))
4849                 return NULL;
4850         arg1 = arg1 / 3;
4851         if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
4852                 return PyErr_NoMemory();
4853         if (!getishortarray(args, 2, 0, 3 * arg1 , (short *) arg2))
4854                 return NULL;
4855         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4856                 return PyErr_NoMemory();
4857         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4858                 return NULL;
4859         splfs( arg1 , arg2 , arg3 );
4860         PyMem_DEL(arg2);
4861         PyMem_DEL(arg3);
4862         Py_INCREF(Py_None);
4863         return Py_None;
4864 }
4865
4866 /* void splf2s long s short s[2*arg1] u_short s[arg1] */
4867
4868 static PyObject *
4869 gl_splf2s(self, args)
4870         PyObject *self;
4871         PyObject *args;
4872 {
4873         long arg1 ;
4874         short (* arg2) [ 2 ] ;
4875         unsigned short * arg3 ;
4876         if (!getilongarraysize(args, 2, 0, &arg1))
4877                 return NULL;
4878         arg1 = arg1 / 2;
4879         if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
4880                 return PyErr_NoMemory();
4881         if (!getishortarray(args, 2, 0, 2 * arg1 , (short *) arg2))
4882                 return NULL;
4883         if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4884                 return PyErr_NoMemory();
4885         if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4886                 return NULL;
4887         splf2s( arg1 , arg2 , arg3 );
4888         PyMem_DEL(arg2);
4889         PyMem_DEL(arg3);
4890         Py_INCREF(Py_None);
4891         return Py_None;
4892 }
4893
4894 /* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */
4895
4896 static PyObject *
4897 gl_rpatch(self, args)
4898         PyObject *self;
4899         PyObject *args;
4900 {
4901         float arg1 [ 4 ] [ 4 ] ;
4902         float arg2 [ 4 ] [ 4 ] ;
4903         float arg3 [ 4 ] [ 4 ] ;
4904         float arg4 [ 4 ] [ 4 ] ;
4905         if (!getifloatarray(args, 4, 0, 4 * 4 , (float *) arg1))
4906                 return NULL;
4907         if (!getifloatarray(args, 4, 1, 4 * 4 , (float *) arg2))
4908                 return NULL;
4909         if (!getifloatarray(args, 4, 2, 4 * 4 , (float *) arg3))
4910                 return NULL;
4911         if (!getifloatarray(args, 4, 3, 4 * 4 , (float *) arg4))
4912                 return NULL;
4913         rpatch( arg1 , arg2 , arg3 , arg4 );
4914         Py_INCREF(Py_None);
4915         return Py_None;
4916 }
4917
4918 /* void ortho2 float s float s float s float s */
4919
4920 static PyObject *
4921 gl_ortho2(self, args)
4922         PyObject *self;
4923         PyObject *args;
4924 {
4925         float arg1 ;
4926         float arg2 ;
4927         float arg3 ;
4928         float arg4 ;
4929         if (!getifloatarg(args, 4, 0, &arg1))
4930                 return NULL;
4931         if (!getifloatarg(args, 4, 1, &arg2))
4932                 return NULL;
4933         if (!getifloatarg(args, 4, 2, &arg3))
4934                 return NULL;
4935         if (!getifloatarg(args, 4, 3, &arg4))
4936                 return NULL;
4937         ortho2( arg1 , arg2 , arg3 , arg4 );
4938         Py_INCREF(Py_None);
4939         return Py_None;
4940 }
4941
4942 /* void rect float s float s float s float s */
4943
4944 static PyObject *
4945 gl_rect(self, args)
4946         PyObject *self;
4947         PyObject *args;
4948 {
4949         float arg1 ;
4950         float arg2 ;
4951         float arg3 ;
4952         float arg4 ;
4953         if (!getifloatarg(args, 4, 0, &arg1))
4954                 return NULL;
4955         if (!getifloatarg(args, 4, 1, &arg2))
4956                 return NULL;
4957         if (!getifloatarg(args, 4, 2, &arg3))
4958                 return NULL;
4959         if (!getifloatarg(args, 4, 3, &arg4))
4960                 return NULL;
4961         rect( arg1 , arg2 , arg3 , arg4 );
4962         Py_INCREF(Py_None);
4963         return Py_None;
4964 }
4965
4966 /* void rectf float s float s float s float s */
4967
4968 static PyObject *
4969 gl_rectf(self, args)
4970         PyObject *self;
4971         PyObject *args;
4972 {
4973         float arg1 ;
4974         float arg2 ;
4975         float arg3 ;
4976         float arg4 ;
4977         if (!getifloatarg(args, 4, 0, &arg1))
4978                 return NULL;
4979         if (!getifloatarg(args, 4, 1, &arg2))
4980                 return NULL;
4981         if (!getifloatarg(args, 4, 2, &arg3))
4982                 return NULL;
4983         if (!getifloatarg(args, 4, 3, &arg4))
4984                 return NULL;
4985         rectf( arg1 , arg2 , arg3 , arg4 );
4986         Py_INCREF(Py_None);
4987         return Py_None;
4988 }
4989
4990 /* void xfpt4 float s float s float s float s */
4991
4992 static PyObject *
4993 gl_xfpt4(self, args)
4994         PyObject *self;
4995         PyObject *args;
4996 {
4997         float arg1 ;
4998         float arg2 ;
4999         float arg3 ;
5000         float arg4 ;
5001         if (!getifloatarg(args, 4, 0, &arg1))
5002                 return NULL;
5003         if (!getifloatarg(args, 4, 1, &arg2))
5004                 return NULL;
5005         if (!getifloatarg(args, 4, 2, &arg3))
5006                 return NULL;
5007         if (!getifloatarg(args, 4, 3, &arg4))
5008                 return NULL;
5009         xfpt4( arg1 , arg2 , arg3 , arg4 );
5010         Py_INCREF(Py_None);
5011         return Py_None;
5012 }
5013
5014 /* void textport short s short s short s short s */
5015
5016 static PyObject *
5017 gl_textport(self, args)
5018         PyObject *self;
5019         PyObject *args;
5020 {
5021         short arg1 ;
5022         short arg2 ;
5023         short arg3 ;
5024         short arg4 ;
5025         if (!getishortarg(args, 4, 0, &arg1))
5026                 return NULL;
5027         if (!getishortarg(args, 4, 1, &arg2))
5028                 return NULL;
5029         if (!getishortarg(args, 4, 2, &arg3))
5030                 return NULL;
5031         if (!getishortarg(args, 4, 3, &arg4))
5032                 return NULL;
5033         textport( arg1 , arg2 , arg3 , arg4 );
5034         Py_INCREF(Py_None);
5035         return Py_None;
5036 }
5037
5038 /* void mapcolor short s short s short s short s */
5039
5040 static PyObject *
5041 gl_mapcolor(self, args)
5042         PyObject *self;
5043         PyObject *args;
5044 {
5045         short arg1 ;
5046         short arg2 ;
5047         short arg3 ;
5048         short arg4 ;
5049         if (!getishortarg(args, 4, 0, &arg1))
5050                 return NULL;
5051         if (!getishortarg(args, 4, 1, &arg2))
5052                 return NULL;
5053         if (!getishortarg(args, 4, 2, &arg3))
5054                 return NULL;
5055         if (!getishortarg(args, 4, 3, &arg4))
5056                 return NULL;
5057         mapcolor( arg1 , arg2 , arg3 , arg4 );
5058         Py_INCREF(Py_None);
5059         return Py_None;
5060 }
5061
5062 /* void scrmask short s short s short s short s */
5063
5064 static PyObject *
5065 gl_scrmask(self, args)
5066         PyObject *self;
5067         PyObject *args;
5068 {
5069         short arg1 ;
5070         short arg2 ;
5071         short arg3 ;
5072         short arg4 ;
5073         if (!getishortarg(args, 4, 0, &arg1))
5074                 return NULL;
5075         if (!getishortarg(args, 4, 1, &arg2))
5076                 return NULL;
5077         if (!getishortarg(args, 4, 2, &arg3))
5078                 return NULL;
5079         if (!getishortarg(args, 4, 3, &arg4))
5080                 return NULL;
5081         scrmask( arg1 , arg2 , arg3 , arg4 );
5082         Py_INCREF(Py_None);
5083         return Py_None;
5084 }
5085
5086 /* void setvaluator short s short s short s short s */
5087
5088 static PyObject *
5089 gl_setvaluator(self, args)
5090         PyObject *self;
5091         PyObject *args;
5092 {
5093         short arg1 ;
5094         short arg2 ;
5095         short arg3 ;
5096         short arg4 ;
5097         if (!getishortarg(args, 4, 0, &arg1))
5098                 return NULL;
5099         if (!getishortarg(args, 4, 1, &arg2))
5100                 return NULL;
5101         if (!getishortarg(args, 4, 2, &arg3))
5102                 return NULL;
5103         if (!getishortarg(args, 4, 3, &arg4))
5104                 return NULL;
5105         setvaluator( arg1 , arg2 , arg3 , arg4 );
5106         Py_INCREF(Py_None);
5107         return Py_None;
5108 }
5109
5110 /* void viewport short s short s short s short s */
5111
5112 static PyObject *
5113 gl_viewport(self, args)
5114         PyObject *self;
5115         PyObject *args;
5116 {
5117         short arg1 ;
5118         short arg2 ;
5119         short arg3 ;
5120         short arg4 ;
5121         if (!getishortarg(args, 4, 0, &arg1))
5122                 return NULL;
5123         if (!getishortarg(args, 4, 1, &arg2))
5124                 return NULL;
5125         if (!getishortarg(args, 4, 2, &arg3))
5126                 return NULL;
5127         if (!getishortarg(args, 4, 3, &arg4))
5128                 return NULL;
5129         viewport( arg1 , arg2 , arg3 , arg4 );
5130         Py_INCREF(Py_None);
5131         return Py_None;
5132 }
5133
5134 /* void shaderange short s short s short s short s */
5135
5136 static PyObject *
5137 gl_shaderange(self, args)
5138         PyObject *self;
5139         PyObject *args;
5140 {
5141         short arg1 ;
5142         short arg2 ;
5143         short arg3 ;
5144         short arg4 ;
5145         if (!getishortarg(args, 4, 0, &arg1))
5146                 return NULL;
5147         if (!getishortarg(args, 4, 1, &arg2))
5148                 return NULL;
5149         if (!getishortarg(args, 4, 2, &arg3))
5150                 return NULL;
5151         if (!getishortarg(args, 4, 3, &arg4))
5152                 return NULL;
5153         shaderange( arg1 , arg2 , arg3 , arg4 );
5154         Py_INCREF(Py_None);
5155         return Py_None;
5156 }
5157
5158 /* void xfpt4s short s short s short s short s */
5159
5160 static PyObject *
5161 gl_xfpt4s(self, args)
5162         PyObject *self;
5163         PyObject *args;
5164 {
5165         short arg1 ;
5166         short arg2 ;
5167         short arg3 ;
5168         short arg4 ;
5169         if (!getishortarg(args, 4, 0, &arg1))
5170                 return NULL;
5171         if (!getishortarg(args, 4, 1, &arg2))
5172                 return NULL;
5173         if (!getishortarg(args, 4, 2, &arg3))
5174                 return NULL;
5175         if (!getishortarg(args, 4, 3, &arg4))
5176                 return NULL;
5177         xfpt4s( arg1 , arg2 , arg3 , arg4 );
5178         Py_INCREF(Py_None);
5179         return Py_None;
5180 }
5181
5182 /* void rectfi long s long s long s long s */
5183
5184 static PyObject *
5185 gl_rectfi(self, args)
5186         PyObject *self;
5187         PyObject *args;
5188 {
5189         long arg1 ;
5190         long arg2 ;
5191         long arg3 ;
5192         long arg4 ;
5193         if (!getilongarg(args, 4, 0, &arg1))
5194                 return NULL;
5195         if (!getilongarg(args, 4, 1, &arg2))
5196                 return NULL;
5197         if (!getilongarg(args, 4, 2, &arg3))
5198                 return NULL;
5199         if (!getilongarg(args, 4, 3, &arg4))
5200                 return NULL;
5201         rectfi( arg1 , arg2 , arg3 , arg4 );
5202         Py_INCREF(Py_None);
5203         return Py_None;
5204 }
5205
5206 /* void recti long s long s long s long s */
5207
5208 static PyObject *
5209 gl_recti(self, args)
5210         PyObject *self;
5211         PyObject *args;
5212 {
5213         long arg1 ;
5214         long arg2 ;
5215         long arg3 ;
5216         long arg4 ;
5217         if (!getilongarg(args, 4, 0, &arg1))
5218                 return NULL;
5219         if (!getilongarg(args, 4, 1, &arg2))
5220                 return NULL;
5221         if (!getilongarg(args, 4, 2, &arg3))
5222                 return NULL;
5223         if (!getilongarg(args, 4, 3, &arg4))
5224                 return NULL;
5225         recti( arg1 , arg2 , arg3 , arg4 );
5226         Py_INCREF(Py_None);
5227         return Py_None;
5228 }
5229
5230 /* void xfpt4i long s long s long s long s */
5231
5232 static PyObject *
5233 gl_xfpt4i(self, args)
5234         PyObject *self;
5235         PyObject *args;
5236 {
5237         long arg1 ;
5238         long arg2 ;
5239         long arg3 ;
5240         long arg4 ;
5241         if (!getilongarg(args, 4, 0, &arg1))
5242                 return NULL;
5243         if (!getilongarg(args, 4, 1, &arg2))
5244                 return NULL;
5245         if (!getilongarg(args, 4, 2, &arg3))
5246                 return NULL;
5247         if (!getilongarg(args, 4, 3, &arg4))
5248                 return NULL;
5249         xfpt4i( arg1 , arg2 , arg3 , arg4 );
5250         Py_INCREF(Py_None);
5251         return Py_None;
5252 }
5253
5254 /* void prefposition long s long s long s long s */
5255
5256 static PyObject *
5257 gl_prefposition(self, args)
5258         PyObject *self;
5259         PyObject *args;
5260 {
5261         long arg1 ;
5262         long arg2 ;
5263         long arg3 ;
5264         long arg4 ;
5265         if (!getilongarg(args, 4, 0, &arg1))
5266                 return NULL;
5267         if (!getilongarg(args, 4, 1, &arg2))
5268                 return NULL;
5269         if (!getilongarg(args, 4, 2, &arg3))
5270                 return NULL;
5271         if (!getilongarg(args, 4, 3, &arg4))
5272                 return NULL;
5273         prefposition( arg1 , arg2 , arg3 , arg4 );
5274         Py_INCREF(Py_None);
5275         return Py_None;
5276 }
5277
5278 /* void arc float s float s float s short s short s */
5279
5280 static PyObject *
5281 gl_arc(self, args)
5282         PyObject *self;
5283         PyObject *args;
5284 {
5285         float arg1 ;
5286         float arg2 ;
5287         float arg3 ;
5288         short arg4 ;
5289         short arg5 ;
5290         if (!getifloatarg(args, 5, 0, &arg1))
5291                 return NULL;
5292         if (!getifloatarg(args, 5, 1, &arg2))
5293                 return NULL;
5294         if (!getifloatarg(args, 5, 2, &arg3))
5295                 return NULL;
5296         if (!getishortarg(args, 5, 3, &arg4))
5297                 return NULL;
5298         if (!getishortarg(args, 5, 4, &arg5))
5299                 return NULL;
5300         arc( arg1 , arg2 , arg3 , arg4 , arg5 );
5301         Py_INCREF(Py_None);
5302         return Py_None;
5303 }
5304
5305 /* void arcf float s float s float s short s short s */
5306
5307 static PyObject *
5308 gl_arcf(self, args)
5309         PyObject *self;
5310         PyObject *args;
5311 {
5312         float arg1 ;
5313         float arg2 ;
5314         float arg3 ;
5315         short arg4 ;
5316         short arg5 ;
5317         if (!getifloatarg(args, 5, 0, &arg1))
5318                 return NULL;
5319         if (!getifloatarg(args, 5, 1, &arg2))
5320                 return NULL;
5321         if (!getifloatarg(args, 5, 2, &arg3))
5322                 return NULL;
5323         if (!getishortarg(args, 5, 3, &arg4))
5324                 return NULL;
5325         if (!getishortarg(args, 5, 4, &arg5))
5326                 return NULL;
5327         arcf( arg1 , arg2 , arg3 , arg4 , arg5 );
5328         Py_INCREF(Py_None);
5329         return Py_None;
5330 }
5331
5332 /* void arcfi long s long s long s short s short s */
5333
5334 static PyObject *
5335 gl_arcfi(self, args)
5336         PyObject *self;
5337         PyObject *args;
5338 {
5339         long arg1 ;
5340         long arg2 ;
5341         long arg3 ;
5342         short arg4 ;
5343         short arg5 ;
5344         if (!getilongarg(args, 5, 0, &arg1))
5345                 return NULL;
5346         if (!getilongarg(args, 5, 1, &arg2))
5347                 return NULL;
5348         if (!getilongarg(args, 5, 2, &arg3))
5349                 return NULL;
5350         if (!getishortarg(args, 5, 3, &arg4))
5351                 return NULL;
5352         if (!getishortarg(args, 5, 4, &arg5))
5353                 return NULL;
5354         arcfi( arg1 , arg2 , arg3 , arg4 , arg5 );
5355         Py_INCREF(Py_None);
5356         return Py_None;
5357 }
5358
5359 /* void arci long s long s long s short s short s */
5360
5361 static PyObject *
5362 gl_arci(self, args)
5363         PyObject *self;
5364         PyObject *args;
5365 {
5366         long arg1 ;
5367         long arg2 ;
5368         long arg3 ;
5369         short arg4 ;
5370         short arg5 ;
5371         if (!getilongarg(args, 5, 0, &arg1))
5372                 return NULL;
5373         if (!getilongarg(args, 5, 1, &arg2))
5374                 return NULL;
5375         if (!getilongarg(args, 5, 2, &arg3))
5376                 return NULL;
5377         if (!getishortarg(args, 5, 3, &arg4))
5378                 return NULL;
5379         if (!getishortarg(args, 5, 4, &arg5))
5380                 return NULL;
5381         arci( arg1 , arg2 , arg3 , arg4 , arg5 );
5382         Py_INCREF(Py_None);
5383         return Py_None;
5384 }
5385
5386 /* void bbox2 short s short s float s float s float s float s */
5387
5388 static PyObject *
5389 gl_bbox2(self, args)
5390         PyObject *self;
5391         PyObject *args;
5392 {
5393         short arg1 ;
5394         short arg2 ;
5395         float arg3 ;
5396         float arg4 ;
5397         float arg5 ;
5398         float arg6 ;
5399         if (!getishortarg(args, 6, 0, &arg1))
5400                 return NULL;
5401         if (!getishortarg(args, 6, 1, &arg2))
5402                 return NULL;
5403         if (!getifloatarg(args, 6, 2, &arg3))
5404                 return NULL;
5405         if (!getifloatarg(args, 6, 3, &arg4))
5406                 return NULL;
5407         if (!getifloatarg(args, 6, 4, &arg5))
5408                 return NULL;
5409         if (!getifloatarg(args, 6, 5, &arg6))
5410                 return NULL;
5411         bbox2( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5412         Py_INCREF(Py_None);
5413         return Py_None;
5414 }
5415
5416 /* void bbox2i short s short s long s long s long s long s */
5417
5418 static PyObject *
5419 gl_bbox2i(self, args)
5420         PyObject *self;
5421         PyObject *args;
5422 {
5423         short arg1 ;
5424         short arg2 ;
5425         long arg3 ;
5426         long arg4 ;
5427         long arg5 ;
5428         long arg6 ;
5429         if (!getishortarg(args, 6, 0, &arg1))
5430                 return NULL;
5431         if (!getishortarg(args, 6, 1, &arg2))
5432                 return NULL;
5433         if (!getilongarg(args, 6, 2, &arg3))
5434                 return NULL;
5435         if (!getilongarg(args, 6, 3, &arg4))
5436                 return NULL;
5437         if (!getilongarg(args, 6, 4, &arg5))
5438                 return NULL;
5439         if (!getilongarg(args, 6, 5, &arg6))
5440                 return NULL;
5441         bbox2i( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5442         Py_INCREF(Py_None);
5443         return Py_None;
5444 }
5445
5446 /* void bbox2s short s short s short s short s short s short s */
5447
5448 static PyObject *
5449 gl_bbox2s(self, args)
5450         PyObject *self;
5451         PyObject *args;
5452 {
5453         short arg1 ;
5454         short arg2 ;
5455         short arg3 ;
5456         short arg4 ;
5457         short arg5 ;
5458         short arg6 ;
5459         if (!getishortarg(args, 6, 0, &arg1))
5460                 return NULL;
5461         if (!getishortarg(args, 6, 1, &arg2))
5462                 return NULL;
5463         if (!getishortarg(args, 6, 2, &arg3))
5464                 return NULL;
5465         if (!getishortarg(args, 6, 3, &arg4))
5466                 return NULL;
5467         if (!getishortarg(args, 6, 4, &arg5))
5468                 return NULL;
5469         if (!getishortarg(args, 6, 5, &arg6))
5470                 return NULL;
5471         bbox2s( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5472         Py_INCREF(Py_None);
5473         return Py_None;
5474 }
5475
5476 /* void blink short s short s short s short s short s */
5477
5478 static PyObject *
5479 gl_blink(self, args)
5480         PyObject *self;
5481         PyObject *args;
5482 {
5483         short arg1 ;
5484         short arg2 ;
5485         short arg3 ;
5486         short arg4 ;
5487         short arg5 ;
5488         if (!getishortarg(args, 5, 0, &arg1))
5489                 return NULL;
5490         if (!getishortarg(args, 5, 1, &arg2))
5491                 return NULL;
5492         if (!getishortarg(args, 5, 2, &arg3))
5493                 return NULL;
5494         if (!getishortarg(args, 5, 3, &arg4))
5495                 return NULL;
5496         if (!getishortarg(args, 5, 4, &arg5))
5497                 return NULL;
5498         blink( arg1 , arg2 , arg3 , arg4 , arg5 );
5499         Py_INCREF(Py_None);
5500         return Py_None;
5501 }
5502
5503 /* void ortho float s float s float s float s float s float s */
5504
5505 static PyObject *
5506 gl_ortho(self, args)
5507         PyObject *self;
5508         PyObject *args;
5509 {
5510         float arg1 ;
5511         float arg2 ;
5512         float arg3 ;
5513         float arg4 ;
5514         float arg5 ;
5515         float arg6 ;
5516         if (!getifloatarg(args, 6, 0, &arg1))
5517                 return NULL;
5518         if (!getifloatarg(args, 6, 1, &arg2))
5519                 return NULL;
5520         if (!getifloatarg(args, 6, 2, &arg3))
5521                 return NULL;
5522         if (!getifloatarg(args, 6, 3, &arg4))
5523                 return NULL;
5524         if (!getifloatarg(args, 6, 4, &arg5))
5525                 return NULL;
5526         if (!getifloatarg(args, 6, 5, &arg6))
5527                 return NULL;
5528         ortho( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5529         Py_INCREF(Py_None);
5530         return Py_None;
5531 }
5532
5533 /* void window float s float s float s float s float s float s */
5534
5535 static PyObject *
5536 gl_window(self, args)
5537         PyObject *self;
5538         PyObject *args;
5539 {
5540         float arg1 ;
5541         float arg2 ;
5542         float arg3 ;
5543         float arg4 ;
5544         float arg5 ;
5545         float arg6 ;
5546         if (!getifloatarg(args, 6, 0, &arg1))
5547                 return NULL;
5548         if (!getifloatarg(args, 6, 1, &arg2))
5549                 return NULL;
5550         if (!getifloatarg(args, 6, 2, &arg3))
5551                 return NULL;
5552         if (!getifloatarg(args, 6, 3, &arg4))
5553                 return NULL;
5554         if (!getifloatarg(args, 6, 4, &arg5))
5555                 return NULL;
5556         if (!getifloatarg(args, 6, 5, &arg6))
5557                 return NULL;
5558         window( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5559         Py_INCREF(Py_None);
5560         return Py_None;
5561 }
5562
5563 /* void lookat float s float s float s float s float s float s short s */
5564
5565 static PyObject *
5566 gl_lookat(self, args)
5567         PyObject *self;
5568         PyObject *args;
5569 {
5570         float arg1 ;
5571         float arg2 ;
5572         float arg3 ;
5573         float arg4 ;
5574         float arg5 ;
5575         float arg6 ;
5576         short arg7 ;
5577         if (!getifloatarg(args, 7, 0, &arg1))
5578                 return NULL;
5579         if (!getifloatarg(args, 7, 1, &arg2))
5580                 return NULL;
5581         if (!getifloatarg(args, 7, 2, &arg3))
5582                 return NULL;
5583         if (!getifloatarg(args, 7, 3, &arg4))
5584                 return NULL;
5585         if (!getifloatarg(args, 7, 4, &arg5))
5586                 return NULL;
5587         if (!getifloatarg(args, 7, 5, &arg6))
5588                 return NULL;
5589         if (!getishortarg(args, 7, 6, &arg7))
5590                 return NULL;
5591         lookat( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
5592         Py_INCREF(Py_None);
5593         return Py_None;
5594 }
5595
5596 /* void perspective short s float s float s float s */
5597
5598 static PyObject *
5599 gl_perspective(self, args)
5600         PyObject *self;
5601         PyObject *args;
5602 {
5603         short arg1 ;
5604         float arg2 ;
5605         float arg3 ;
5606         float arg4 ;
5607         if (!getishortarg(args, 4, 0, &arg1))
5608                 return NULL;
5609         if (!getifloatarg(args, 4, 1, &arg2))
5610                 return NULL;
5611         if (!getifloatarg(args, 4, 2, &arg3))
5612                 return NULL;
5613         if (!getifloatarg(args, 4, 3, &arg4))
5614                 return NULL;
5615         perspective( arg1 , arg2 , arg3 , arg4 );
5616         Py_INCREF(Py_None);
5617         return Py_None;
5618 }
5619
5620 /* void polarview float s short s short s short s */
5621
5622 static PyObject *
5623 gl_polarview(self, args)
5624         PyObject *self;
5625         PyObject *args;
5626 {
5627         float arg1 ;
5628         short arg2 ;
5629         short arg3 ;
5630         short arg4 ;
5631         if (!getifloatarg(args, 4, 0, &arg1))
5632                 return NULL;
5633         if (!getishortarg(args, 4, 1, &arg2))
5634                 return NULL;
5635         if (!getishortarg(args, 4, 2, &arg3))
5636                 return NULL;
5637         if (!getishortarg(args, 4, 3, &arg4))
5638                 return NULL;
5639         polarview( arg1 , arg2 , arg3 , arg4 );
5640         Py_INCREF(Py_None);
5641         return Py_None;
5642 }
5643
5644 /* void arcfs short s short s short s short s short s */
5645
5646 static PyObject *
5647 gl_arcfs(self, args)
5648         PyObject *self;
5649         PyObject *args;
5650 {
5651         short arg1 ;
5652         short arg2 ;
5653         short arg3 ;
5654         short arg4 ;
5655         short arg5 ;
5656         if (!getishortarg(args, 5, 0, &arg1))
5657                 return NULL;
5658         if (!getishortarg(args, 5, 1, &arg2))
5659                 return NULL;
5660         if (!getishortarg(args, 5, 2, &arg3))
5661                 return NULL;
5662         if (!getishortarg(args, 5, 3, &arg4))
5663                 return NULL;
5664         if (!getishortarg(args, 5, 4, &arg5))
5665                 return NULL;
5666         arcfs( arg1 , arg2 , arg3 , arg4 , arg5 );
5667         Py_INCREF(Py_None);
5668         return Py_None;
5669 }
5670
5671 /* void arcs short s short s short s short s short s */
5672
5673 static PyObject *
5674 gl_arcs(self, args)
5675         PyObject *self;
5676         PyObject *args;
5677 {
5678         short arg1 ;
5679         short arg2 ;
5680         short arg3 ;
5681         short arg4 ;
5682         short arg5 ;
5683         if (!getishortarg(args, 5, 0, &arg1))
5684                 return NULL;
5685         if (!getishortarg(args, 5, 1, &arg2))
5686                 return NULL;
5687         if (!getishortarg(args, 5, 2, &arg3))
5688                 return NULL;
5689         if (!getishortarg(args, 5, 3, &arg4))
5690                 return NULL;
5691         if (!getishortarg(args, 5, 4, &arg5))
5692                 return NULL;
5693         arcs( arg1 , arg2 , arg3 , arg4 , arg5 );
5694         Py_INCREF(Py_None);
5695         return Py_None;
5696 }
5697
5698 /* void rectcopy short s short s short s short s short s short s */
5699
5700 static PyObject *
5701 gl_rectcopy(self, args)
5702         PyObject *self;
5703         PyObject *args;
5704 {
5705         short arg1 ;
5706         short arg2 ;
5707         short arg3 ;
5708         short arg4 ;
5709         short arg5 ;
5710         short arg6 ;
5711         if (!getishortarg(args, 6, 0, &arg1))
5712                 return NULL;
5713         if (!getishortarg(args, 6, 1, &arg2))
5714                 return NULL;
5715         if (!getishortarg(args, 6, 2, &arg3))
5716                 return NULL;
5717         if (!getishortarg(args, 6, 3, &arg4))
5718                 return NULL;
5719         if (!getishortarg(args, 6, 4, &arg5))
5720                 return NULL;
5721         if (!getishortarg(args, 6, 5, &arg6))
5722                 return NULL;
5723         rectcopy( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5724         Py_INCREF(Py_None);
5725         return Py_None;
5726 }
5727
5728 /* void RGBcursor short s short s short s short s short s short s short s */
5729
5730 static PyObject *
5731 gl_RGBcursor(self, args)
5732         PyObject *self;
5733         PyObject *args;
5734 {
5735         short arg1 ;
5736         short arg2 ;
5737         short arg3 ;
5738         short arg4 ;
5739         short arg5 ;
5740         short arg6 ;
5741         short arg7 ;
5742         if (!getishortarg(args, 7, 0, &arg1))
5743                 return NULL;
5744         if (!getishortarg(args, 7, 1, &arg2))
5745                 return NULL;
5746         if (!getishortarg(args, 7, 2, &arg3))
5747                 return NULL;
5748         if (!getishortarg(args, 7, 3, &arg4))
5749                 return NULL;
5750         if (!getishortarg(args, 7, 4, &arg5))
5751                 return NULL;
5752         if (!getishortarg(args, 7, 5, &arg6))
5753                 return NULL;
5754         if (!getishortarg(args, 7, 6, &arg7))
5755                 return NULL;
5756         RGBcursor( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
5757         Py_INCREF(Py_None);
5758         return Py_None;
5759 }
5760
5761 /* long getbutton short s */
5762
5763 static PyObject *
5764 gl_getbutton(self, args)
5765         PyObject *self;
5766         PyObject *args;
5767 {
5768         long retval;
5769         short arg1 ;
5770         if (!getishortarg(args, 1, 0, &arg1))
5771                 return NULL;
5772         retval = getbutton( arg1 );
5773         return mknewlongobject(retval);
5774 }
5775
5776 /* long getcmmode */
5777
5778 static PyObject *
5779 gl_getcmmode(self, args)
5780         PyObject *self;
5781         PyObject *args;
5782 {
5783         long retval;
5784         retval = getcmmode( );
5785         return mknewlongobject(retval);
5786 }
5787
5788 /* long getlsbackup */
5789
5790 static PyObject *
5791 gl_getlsbackup(self, args)
5792         PyObject *self;
5793         PyObject *args;
5794 {
5795         long retval;
5796         retval = getlsbackup( );
5797         return mknewlongobject(retval);
5798 }
5799
5800 /* long getresetls */
5801
5802 static PyObject *
5803 gl_getresetls(self, args)
5804         PyObject *self;
5805         PyObject *args;
5806 {
5807         long retval;
5808         retval = getresetls( );
5809         return mknewlongobject(retval);
5810 }
5811
5812 /* long getdcm */
5813
5814 static PyObject *
5815 gl_getdcm(self, args)
5816         PyObject *self;
5817         PyObject *args;
5818 {
5819         long retval;
5820         retval = getdcm( );
5821         return mknewlongobject(retval);
5822 }
5823
5824 /* long getzbuffer */
5825
5826 static PyObject *
5827 gl_getzbuffer(self, args)
5828         PyObject *self;
5829         PyObject *args;
5830 {
5831         long retval;
5832         retval = getzbuffer( );
5833         return mknewlongobject(retval);
5834 }
5835
5836 /* long ismex */
5837
5838 static PyObject *
5839 gl_ismex(self, args)
5840         PyObject *self;
5841         PyObject *args;
5842 {
5843         long retval;
5844         retval = ismex( );
5845         return mknewlongobject(retval);
5846 }
5847
5848 /* long isobj long s */
5849
5850 static PyObject *
5851 gl_isobj(self, args)
5852         PyObject *self;
5853         PyObject *args;
5854 {
5855         long retval;
5856         long arg1 ;
5857         if (!getilongarg(args, 1, 0, &arg1))
5858                 return NULL;
5859         retval = isobj( arg1 );
5860         return mknewlongobject(retval);
5861 }
5862
5863 /* long isqueued short s */
5864
5865 static PyObject *
5866 gl_isqueued(self, args)
5867         PyObject *self;
5868         PyObject *args;
5869 {
5870         long retval;
5871         short arg1 ;
5872         if (!getishortarg(args, 1, 0, &arg1))
5873                 return NULL;
5874         retval = isqueued( arg1 );
5875         return mknewlongobject(retval);
5876 }
5877
5878 /* long istag long s */
5879
5880 static PyObject *
5881 gl_istag(self, args)
5882         PyObject *self;
5883         PyObject *args;
5884 {
5885         long retval;
5886         long arg1 ;
5887         if (!getilongarg(args, 1, 0, &arg1))
5888                 return NULL;
5889         retval = istag( arg1 );
5890         return mknewlongobject(retval);
5891 }
5892
5893 /* long genobj */
5894
5895 static PyObject *
5896 gl_genobj(self, args)
5897         PyObject *self;
5898         PyObject *args;
5899 {
5900         long retval;
5901         retval = genobj( );
5902         return mknewlongobject(retval);
5903 }
5904
5905 /* long gentag */
5906
5907 static PyObject *
5908 gl_gentag(self, args)
5909         PyObject *self;
5910         PyObject *args;
5911 {
5912         long retval;
5913         retval = gentag( );
5914         return mknewlongobject(retval);
5915 }
5916
5917 /* long getbuffer */
5918
5919 static PyObject *
5920 gl_getbuffer(self, args)
5921         PyObject *self;
5922         PyObject *args;
5923 {
5924         long retval;
5925         retval = getbuffer( );
5926         return mknewlongobject(retval);
5927 }
5928
5929 /* long getcolor */
5930
5931 static PyObject *
5932 gl_getcolor(self, args)
5933         PyObject *self;
5934         PyObject *args;
5935 {
5936         long retval;
5937         retval = getcolor( );
5938         return mknewlongobject(retval);
5939 }
5940
5941 /* long getdisplaymode */
5942
5943 static PyObject *
5944 gl_getdisplaymode(self, args)
5945         PyObject *self;
5946         PyObject *args;
5947 {
5948         long retval;
5949         retval = getdisplaymode( );
5950         return mknewlongobject(retval);
5951 }
5952
5953 /* long getfont */
5954
5955 static PyObject *
5956 gl_getfont(self, args)
5957         PyObject *self;
5958         PyObject *args;
5959 {
5960         long retval;
5961         retval = getfont( );
5962         return mknewlongobject(retval);
5963 }
5964
5965 /* long getheight */
5966
5967 static PyObject *
5968 gl_getheight(self, args)
5969         PyObject *self;
5970         PyObject *args;
5971 {
5972         long retval;
5973         retval = getheight( );
5974         return mknewlongobject(retval);
5975 }
5976
5977 /* long gethitcode */
5978
5979 static PyObject *
5980 gl_gethitcode(self, args)
5981         PyObject *self;
5982         PyObject *args;
5983 {
5984         long retval;
5985         retval = gethitcode( );
5986         return mknewlongobject(retval);
5987 }
5988
5989 /* long getlstyle */
5990
5991 static PyObject *
5992 gl_getlstyle(self, args)
5993         PyObject *self;
5994         PyObject *args;
5995 {
5996         long retval;
5997         retval = getlstyle( );
5998         return mknewlongobject(retval);
5999 }
6000
6001 /* long getlwidth */
6002
6003 static PyObject *
6004 gl_getlwidth(self, args)
6005         PyObject *self;
6006         PyObject *args;
6007 {
6008         long retval;
6009         retval = getlwidth( );
6010         return mknewlongobject(retval);
6011 }
6012
6013 /* long getmap */
6014
6015 static PyObject *
6016 gl_getmap(self, args)
6017         PyObject *self;
6018         PyObject *args;
6019 {
6020         long retval;
6021         retval = getmap( );
6022         return mknewlongobject(retval);
6023 }
6024
6025 /* long getplanes */
6026
6027 static PyObject *
6028 gl_getplanes(self, args)
6029         PyObject *self;
6030         PyObject *args;
6031 {
6032         long retval;
6033         retval = getplanes( );
6034         return mknewlongobject(retval);
6035 }
6036
6037 /* long getwritemask */
6038
6039 static PyObject *
6040 gl_getwritemask(self, args)
6041         PyObject *self;
6042         PyObject *args;
6043 {
6044         long retval;
6045         retval = getwritemask( );
6046         return mknewlongobject(retval);
6047 }
6048
6049 /* long qtest */
6050
6051 static PyObject *
6052 gl_qtest(self, args)
6053         PyObject *self;
6054         PyObject *args;
6055 {
6056         long retval;
6057         retval = qtest( );
6058         return mknewlongobject(retval);
6059 }
6060
6061 /* long getlsrepeat */
6062
6063 static PyObject *
6064 gl_getlsrepeat(self, args)
6065         PyObject *self;
6066         PyObject *args;
6067 {
6068         long retval;
6069         retval = getlsrepeat( );
6070         return mknewlongobject(retval);
6071 }
6072
6073 /* long getmonitor */
6074
6075 static PyObject *
6076 gl_getmonitor(self, args)
6077         PyObject *self;
6078         PyObject *args;
6079 {
6080         long retval;
6081         retval = getmonitor( );
6082         return mknewlongobject(retval);
6083 }
6084
6085 /* long getopenobj */
6086
6087 static PyObject *
6088 gl_getopenobj(self, args)
6089         PyObject *self;
6090         PyObject *args;
6091 {
6092         long retval;
6093         retval = getopenobj( );
6094         return mknewlongobject(retval);
6095 }
6096
6097 /* long getpattern */
6098
6099 static PyObject *
6100 gl_getpattern(self, args)
6101         PyObject *self;
6102         PyObject *args;
6103 {
6104         long retval;
6105         retval = getpattern( );
6106         return mknewlongobject(retval);
6107 }
6108
6109 /* long winget */
6110
6111 static PyObject *
6112 gl_winget(self, args)
6113         PyObject *self;
6114         PyObject *args;
6115 {
6116         long retval;
6117         retval = winget( );
6118         return mknewlongobject(retval);
6119 }
6120
6121 /* long winattach */
6122
6123 static PyObject *
6124 gl_winattach(self, args)
6125         PyObject *self;
6126         PyObject *args;
6127 {
6128         long retval;
6129         retval = winattach( );
6130         return mknewlongobject(retval);
6131 }
6132
6133 /* long getothermonitor */
6134
6135 static PyObject *
6136 gl_getothermonitor(self, args)
6137         PyObject *self;
6138         PyObject *args;
6139 {
6140         long retval;
6141         retval = getothermonitor( );
6142         return mknewlongobject(retval);
6143 }
6144
6145 /* long newpup */
6146
6147 static PyObject *
6148 gl_newpup(self, args)
6149         PyObject *self;
6150         PyObject *args;
6151 {
6152         long retval;
6153         retval = newpup( );
6154         return mknewlongobject(retval);
6155 }
6156
6157 /* long getvaluator short s */
6158
6159 static PyObject *
6160 gl_getvaluator(self, args)
6161         PyObject *self;
6162         PyObject *args;
6163 {
6164         long retval;
6165         short arg1 ;
6166         if (!getishortarg(args, 1, 0, &arg1))
6167                 return NULL;
6168         retval = getvaluator( arg1 );
6169         return mknewlongobject(retval);
6170 }
6171
6172 /* void winset long s */
6173
6174 static PyObject *
6175 gl_winset(self, args)
6176         PyObject *self;
6177         PyObject *args;
6178 {
6179         long arg1 ;
6180         if (!getilongarg(args, 1, 0, &arg1))
6181                 return NULL;
6182         winset( arg1 );
6183         Py_INCREF(Py_None);
6184         return Py_None;
6185 }
6186
6187 /* long dopup long s */
6188
6189 static PyObject *
6190 gl_dopup(self, args)
6191         PyObject *self;
6192         PyObject *args;
6193 {
6194         long retval;
6195         long arg1 ;
6196         if (!getilongarg(args, 1, 0, &arg1))
6197                 return NULL;
6198         retval = dopup( arg1 );
6199         return mknewlongobject(retval);
6200 }
6201
6202 /* void getdepth short r short r */
6203
6204 static PyObject *
6205 gl_getdepth(self, args)
6206         PyObject *self;
6207         PyObject *args;
6208 {
6209         short arg1 ;
6210         short arg2 ;
6211         getdepth( & arg1 , & arg2 );
6212         { PyObject *v = PyTuple_New( 2 );
6213           if (v == NULL) return NULL;
6214           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6215           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6216           return v;
6217         }
6218 }
6219
6220 /* void getcpos short r short r */
6221
6222 static PyObject *
6223 gl_getcpos(self, args)
6224         PyObject *self;
6225         PyObject *args;
6226 {
6227         short arg1 ;
6228         short arg2 ;
6229         getcpos( & arg1 , & arg2 );
6230         { PyObject *v = PyTuple_New( 2 );
6231           if (v == NULL) return NULL;
6232           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6233           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6234           return v;
6235         }
6236 }
6237
6238 /* void getsize long r long r */
6239
6240 static PyObject *
6241 gl_getsize(self, args)
6242         PyObject *self;
6243         PyObject *args;
6244 {
6245         long arg1 ;
6246         long arg2 ;
6247         getsize( & arg1 , & arg2 );
6248         { PyObject *v = PyTuple_New( 2 );
6249           if (v == NULL) return NULL;
6250           PyTuple_SetItem(v, 0, mknewlongobject(arg1));
6251           PyTuple_SetItem(v, 1, mknewlongobject(arg2));
6252           return v;
6253         }
6254 }
6255
6256 /* void getorigin long r long r */
6257
6258 static PyObject *
6259 gl_getorigin(self, args)
6260         PyObject *self;
6261         PyObject *args;
6262 {
6263         long arg1 ;
6264         long arg2 ;
6265         getorigin( & arg1 , & arg2 );
6266         { PyObject *v = PyTuple_New( 2 );
6267           if (v == NULL) return NULL;
6268           PyTuple_SetItem(v, 0, mknewlongobject(arg1));
6269           PyTuple_SetItem(v, 1, mknewlongobject(arg2));
6270           return v;
6271         }
6272 }
6273
6274 /* void getviewport short r short r short r short r */
6275
6276 static PyObject *
6277 gl_getviewport(self, args)
6278         PyObject *self;
6279         PyObject *args;
6280 {
6281         short arg1 ;
6282         short arg2 ;
6283         short arg3 ;
6284         short arg4 ;
6285         getviewport( & arg1 , & arg2 , & arg3 , & arg4 );
6286         { PyObject *v = PyTuple_New( 4 );
6287           if (v == NULL) return NULL;
6288           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6289           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6290           PyTuple_SetItem(v, 2, mknewshortobject(arg3));
6291           PyTuple_SetItem(v, 3, mknewshortobject(arg4));
6292           return v;
6293         }
6294 }
6295
6296 /* void gettp short r short r short r short r */
6297
6298 static PyObject *
6299 gl_gettp(self, args)
6300         PyObject *self;
6301         PyObject *args;
6302 {
6303         short arg1 ;
6304         short arg2 ;
6305         short arg3 ;
6306         short arg4 ;
6307         gettp( & arg1 , & arg2 , & arg3 , & arg4 );
6308         { PyObject *v = PyTuple_New( 4 );
6309           if (v == NULL) return NULL;
6310           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6311           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6312           PyTuple_SetItem(v, 2, mknewshortobject(arg3));
6313           PyTuple_SetItem(v, 3, mknewshortobject(arg4));
6314           return v;
6315         }
6316 }
6317
6318 /* void getgpos float r float r float r float r */
6319
6320 static PyObject *
6321 gl_getgpos(self, args)
6322         PyObject *self;
6323         PyObject *args;
6324 {
6325         float arg1 ;
6326         float arg2 ;
6327         float arg3 ;
6328         float arg4 ;
6329         getgpos( & arg1 , & arg2 , & arg3 , & arg4 );
6330         { PyObject *v = PyTuple_New( 4 );
6331           if (v == NULL) return NULL;
6332           PyTuple_SetItem(v, 0, mknewfloatobject(arg1));
6333           PyTuple_SetItem(v, 1, mknewfloatobject(arg2));
6334           PyTuple_SetItem(v, 2, mknewfloatobject(arg3));
6335           PyTuple_SetItem(v, 3, mknewfloatobject(arg4));
6336           return v;
6337         }
6338 }
6339
6340 /* void winposition long s long s long s long s */
6341
6342 static PyObject *
6343 gl_winposition(self, args)
6344         PyObject *self;
6345         PyObject *args;
6346 {
6347         long arg1 ;
6348         long arg2 ;
6349         long arg3 ;
6350         long arg4 ;
6351         if (!getilongarg(args, 4, 0, &arg1))
6352                 return NULL;
6353         if (!getilongarg(args, 4, 1, &arg2))
6354                 return NULL;
6355         if (!getilongarg(args, 4, 2, &arg3))
6356                 return NULL;
6357         if (!getilongarg(args, 4, 3, &arg4))
6358                 return NULL;
6359         winposition( arg1 , arg2 , arg3 , arg4 );
6360         Py_INCREF(Py_None);
6361         return Py_None;
6362 }
6363
6364 /* void gRGBcolor short r short r short r */
6365
6366 static PyObject *
6367 gl_gRGBcolor(self, args)
6368         PyObject *self;
6369         PyObject *args;
6370 {
6371         short arg1 ;
6372         short arg2 ;
6373         short arg3 ;
6374         gRGBcolor( & arg1 , & arg2 , & arg3 );
6375         { PyObject *v = PyTuple_New( 3 );
6376           if (v == NULL) return NULL;
6377           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6378           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6379           PyTuple_SetItem(v, 2, mknewshortobject(arg3));
6380           return v;
6381         }
6382 }
6383
6384 /* void gRGBmask short r short r short r */
6385
6386 static PyObject *
6387 gl_gRGBmask(self, args)
6388         PyObject *self;
6389         PyObject *args;
6390 {
6391         short arg1 ;
6392         short arg2 ;
6393         short arg3 ;
6394         gRGBmask( & arg1 , & arg2 , & arg3 );
6395         { PyObject *v = PyTuple_New( 3 );
6396           if (v == NULL) return NULL;
6397           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6398           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6399           PyTuple_SetItem(v, 2, mknewshortobject(arg3));
6400           return v;
6401         }
6402 }
6403
6404 /* void getscrmask short r short r short r short r */
6405
6406 static PyObject *
6407 gl_getscrmask(self, args)
6408         PyObject *self;
6409         PyObject *args;
6410 {
6411         short arg1 ;
6412         short arg2 ;
6413         short arg3 ;
6414         short arg4 ;
6415         getscrmask( & arg1 , & arg2 , & arg3 , & arg4 );
6416         { PyObject *v = PyTuple_New( 4 );
6417           if (v == NULL) return NULL;
6418           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6419           PyTuple_SetItem(v, 1, mknewshortobject(arg2));
6420           PyTuple_SetItem(v, 2, mknewshortobject(arg3));
6421           PyTuple_SetItem(v, 3, mknewshortobject(arg4));
6422           return v;
6423         }
6424 }
6425
6426 /* void getmcolor short s short r short r short r */
6427
6428 static PyObject *
6429 gl_getmcolor(self, args)
6430         PyObject *self;
6431         PyObject *args;
6432 {
6433         short arg1 ;
6434         short arg2 ;
6435         short arg3 ;
6436         short arg4 ;
6437         if (!getishortarg(args, 1, 0, &arg1))
6438                 return NULL;
6439         getmcolor( arg1 , & arg2 , & arg3 , & arg4 );
6440         { PyObject *v = PyTuple_New( 3 );
6441           if (v == NULL) return NULL;
6442           PyTuple_SetItem(v, 0, mknewshortobject(arg2));
6443           PyTuple_SetItem(v, 1, mknewshortobject(arg3));
6444           PyTuple_SetItem(v, 2, mknewshortobject(arg4));
6445           return v;
6446         }
6447 }
6448
6449 /* void mapw long s short s short s float r float r float r float r float r float r */
6450
6451 static PyObject *
6452 gl_mapw(self, args)
6453         PyObject *self;
6454         PyObject *args;
6455 {
6456         long arg1 ;
6457         short arg2 ;
6458         short arg3 ;
6459         float arg4 ;
6460         float arg5 ;
6461         float arg6 ;
6462         float arg7 ;
6463         float arg8 ;
6464         float arg9 ;
6465         if (!getilongarg(args, 3, 0, &arg1))
6466                 return NULL;
6467         if (!getishortarg(args, 3, 1, &arg2))
6468                 return NULL;
6469         if (!getishortarg(args, 3, 2, &arg3))
6470                 return NULL;
6471         mapw( arg1 , arg2 , arg3 , & arg4 , & arg5 , & arg6 , & arg7 , & arg8 , & arg9 );
6472         { PyObject *v = PyTuple_New( 6 );
6473           if (v == NULL) return NULL;
6474           PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
6475           PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
6476           PyTuple_SetItem(v, 2, mknewfloatobject(arg6));
6477           PyTuple_SetItem(v, 3, mknewfloatobject(arg7));
6478           PyTuple_SetItem(v, 4, mknewfloatobject(arg8));
6479           PyTuple_SetItem(v, 5, mknewfloatobject(arg9));
6480           return v;
6481         }
6482 }
6483
6484 /* void mapw2 long s short s short s float r float r */
6485
6486 static PyObject *
6487 gl_mapw2(self, args)
6488         PyObject *self;
6489         PyObject *args;
6490 {
6491         long arg1 ;
6492         short arg2 ;
6493         short arg3 ;
6494         float arg4 ;
6495         float arg5 ;
6496         if (!getilongarg(args, 3, 0, &arg1))
6497                 return NULL;
6498         if (!getishortarg(args, 3, 1, &arg2))
6499                 return NULL;
6500         if (!getishortarg(args, 3, 2, &arg3))
6501                 return NULL;
6502         mapw2( arg1 , arg2 , arg3 , & arg4 , & arg5 );
6503         { PyObject *v = PyTuple_New( 2 );
6504           if (v == NULL) return NULL;
6505           PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
6506           PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
6507           return v;
6508         }
6509 }
6510
6511 /* void getcursor short r u_short r u_short r long r */
6512
6513 static PyObject *
6514 gl_getcursor(self, args)
6515         PyObject *self;
6516         PyObject *args;
6517 {
6518         short arg1 ;
6519         unsigned short arg2 ;
6520         unsigned short arg3 ;
6521         long arg4 ;
6522         getcursor( & arg1 , & arg2 , & arg3 , & arg4 );
6523         { PyObject *v = PyTuple_New( 4 );
6524           if (v == NULL) return NULL;
6525           PyTuple_SetItem(v, 0, mknewshortobject(arg1));
6526           PyTuple_SetItem(v, 1, mknewshortobject((short) arg2));
6527           PyTuple_SetItem(v, 2, mknewshortobject((short) arg3));
6528           PyTuple_SetItem(v, 3, mknewlongobject(arg4));
6529           return v;
6530         }
6531 }
6532
6533 /* void cmode */
6534
6535 static PyObject *
6536 gl_cmode(self, args)
6537         PyObject *self;
6538         PyObject *args;
6539 {
6540         cmode( );
6541         Py_INCREF(Py_None);
6542         return Py_None;
6543 }
6544
6545 /* void concave long s */
6546
6547 static PyObject *
6548 gl_concave(self, args)
6549         PyObject *self;
6550         PyObject *args;
6551 {
6552         long arg1 ;
6553         if (!getilongarg(args, 1, 0, &arg1))
6554                 return NULL;
6555         concave( arg1 );
6556         Py_INCREF(Py_None);
6557         return Py_None;
6558 }
6559
6560 /* void curstype long s */
6561
6562 static PyObject *
6563 gl_curstype(self, args)
6564         PyObject *self;
6565         PyObject *args;
6566 {
6567         long arg1 ;
6568         if (!getilongarg(args, 1, 0, &arg1))
6569                 return NULL;
6570         curstype( arg1 );
6571         Py_INCREF(Py_None);
6572         return Py_None;
6573 }
6574
6575 /* void drawmode long s */
6576
6577 static PyObject *
6578 gl_drawmode(self, args)
6579         PyObject *self;
6580         PyObject *args;
6581 {
6582         long arg1 ;
6583         if (!getilongarg(args, 1, 0, &arg1))
6584                 return NULL;
6585         drawmode( arg1 );
6586         Py_INCREF(Py_None);
6587         return Py_None;
6588 }
6589
6590 /* void gammaramp short s[256] short s[256] short s[256] */
6591
6592 static PyObject *
6593 gl_gammaramp(self, args)
6594         PyObject *self;
6595         PyObject *args;
6596 {
6597         short arg1 [ 256 ] ;
6598         short arg2 [ 256 ] ;
6599         short arg3 [ 256 ] ;
6600         if (!getishortarray(args, 3, 0, 256 , arg1))
6601                 return NULL;
6602         if (!getishortarray(args, 3, 1, 256 , arg2))
6603                 return NULL;
6604         if (!getishortarray(args, 3, 2, 256 , arg3))
6605                 return NULL;
6606         gammaramp( arg1 , arg2 , arg3 );
6607         Py_INCREF(Py_None);
6608         return Py_None;
6609 }
6610
6611 /* long getbackface */
6612
6613 static PyObject *
6614 gl_getbackface(self, args)
6615         PyObject *self;
6616         PyObject *args;
6617 {
6618         long retval;
6619         retval = getbackface( );
6620         return mknewlongobject(retval);
6621 }
6622
6623 /* long getdescender */
6624
6625 static PyObject *
6626 gl_getdescender(self, args)
6627         PyObject *self;
6628         PyObject *args;
6629 {
6630         long retval;
6631         retval = getdescender( );
6632         return mknewlongobject(retval);
6633 }
6634
6635 /* long getdrawmode */
6636
6637 static PyObject *
6638 gl_getdrawmode(self, args)
6639         PyObject *self;
6640         PyObject *args;
6641 {
6642         long retval;
6643         retval = getdrawmode( );
6644         return mknewlongobject(retval);
6645 }
6646
6647 /* long getmmode */
6648
6649 static PyObject *
6650 gl_getmmode(self, args)
6651         PyObject *self;
6652         PyObject *args;
6653 {
6654         long retval;
6655         retval = getmmode( );
6656         return mknewlongobject(retval);
6657 }
6658
6659 /* long getsm */
6660
6661 static PyObject *
6662 gl_getsm(self, args)
6663         PyObject *self;
6664         PyObject *args;
6665 {
6666         long retval;
6667         retval = getsm( );
6668         return mknewlongobject(retval);
6669 }
6670
6671 /* long getvideo long s */
6672
6673 static PyObject *
6674 gl_getvideo(self, args)
6675         PyObject *self;
6676         PyObject *args;
6677 {
6678         long retval;
6679         long arg1 ;
6680         if (!getilongarg(args, 1, 0, &arg1))
6681                 return NULL;
6682         retval = getvideo( arg1 );
6683         return mknewlongobject(retval);
6684 }
6685
6686 /* void imakebackground */
6687
6688 static PyObject *
6689 gl_imakebackground(self, args)
6690         PyObject *self;
6691         PyObject *args;
6692 {
6693         imakebackground( );
6694         Py_INCREF(Py_None);
6695         return Py_None;
6696 }
6697
6698 /* void lmbind short s short s */
6699
6700 static PyObject *
6701 gl_lmbind(self, args)
6702         PyObject *self;
6703         PyObject *args;
6704 {
6705         short arg1 ;
6706         short arg2 ;
6707         if (!getishortarg(args, 2, 0, &arg1))
6708                 return NULL;
6709         if (!getishortarg(args, 2, 1, &arg2))
6710                 return NULL;
6711         lmbind( arg1 , arg2 );
6712         Py_INCREF(Py_None);
6713         return Py_None;
6714 }
6715
6716 /* void lmdef long s long s long s float s[arg3] */
6717
6718 static PyObject *
6719 gl_lmdef(self, args)
6720         PyObject *self;
6721         PyObject *args;
6722 {
6723         long arg1 ;
6724         long arg2 ;
6725         long arg3 ;
6726         float * arg4 ;
6727         if (!getilongarg(args, 3, 0, &arg1))
6728                 return NULL;
6729         if (!getilongarg(args, 3, 1, &arg2))
6730                 return NULL;
6731         if (!getilongarraysize(args, 3, 2, &arg3))
6732                 return NULL;
6733         if ((arg4 = PyMem_NEW(float , arg3 )) == NULL)
6734                 return PyErr_NoMemory();
6735         if (!getifloatarray(args, 3, 2, arg3 , arg4))
6736                 return NULL;
6737         lmdef( arg1 , arg2 , arg3 , arg4 );
6738         PyMem_DEL(arg4);
6739         Py_INCREF(Py_None);
6740         return Py_None;
6741 }
6742
6743 /* void mmode long s */
6744
6745 static PyObject *
6746 gl_mmode(self, args)
6747         PyObject *self;
6748         PyObject *args;
6749 {
6750         long arg1 ;
6751         if (!getilongarg(args, 1, 0, &arg1))
6752                 return NULL;
6753         mmode( arg1 );
6754         Py_INCREF(Py_None);
6755         return Py_None;
6756 }
6757
6758 /* void normal float s[3] */
6759
6760 static PyObject *
6761 gl_normal(self, args)
6762         PyObject *self;
6763         PyObject *args;
6764 {
6765         float arg1 [ 3 ] ;
6766         if (!getifloatarray(args, 1, 0, 3 , arg1))
6767                 return NULL;
6768         normal( arg1 );
6769         Py_INCREF(Py_None);
6770         return Py_None;
6771 }
6772
6773 /* void overlay long s */
6774
6775 static PyObject *
6776 gl_overlay(self, args)
6777         PyObject *self;
6778         PyObject *args;
6779 {
6780         long arg1 ;
6781         if (!getilongarg(args, 1, 0, &arg1))
6782                 return NULL;
6783         overlay( arg1 );
6784         Py_INCREF(Py_None);
6785         return Py_None;
6786 }
6787
6788 /* void RGBrange short s short s short s short s short s short s short s short s */
6789
6790 static PyObject *
6791 gl_RGBrange(self, args)
6792         PyObject *self;
6793         PyObject *args;
6794 {
6795         short arg1 ;
6796         short arg2 ;
6797         short arg3 ;
6798         short arg4 ;
6799         short arg5 ;
6800         short arg6 ;
6801         short arg7 ;
6802         short arg8 ;
6803         if (!getishortarg(args, 8, 0, &arg1))
6804                 return NULL;
6805         if (!getishortarg(args, 8, 1, &arg2))
6806                 return NULL;
6807         if (!getishortarg(args, 8, 2, &arg3))
6808                 return NULL;
6809         if (!getishortarg(args, 8, 3, &arg4))
6810                 return NULL;
6811         if (!getishortarg(args, 8, 4, &arg5))
6812                 return NULL;
6813         if (!getishortarg(args, 8, 5, &arg6))
6814                 return NULL;
6815         if (!getishortarg(args, 8, 6, &arg7))
6816                 return NULL;
6817         if (!getishortarg(args, 8, 7, &arg8))
6818                 return NULL;
6819         RGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 );
6820         Py_INCREF(Py_None);
6821         return Py_None;
6822 }
6823
6824 /* void setvideo long s long s */
6825
6826 static PyObject *
6827 gl_setvideo(self, args)
6828         PyObject *self;
6829         PyObject *args;
6830 {
6831         long arg1 ;
6832         long arg2 ;
6833         if (!getilongarg(args, 2, 0, &arg1))
6834                 return NULL;
6835         if (!getilongarg(args, 2, 1, &arg2))
6836                 return NULL;
6837         setvideo( arg1 , arg2 );
6838         Py_INCREF(Py_None);
6839         return Py_None;
6840 }
6841
6842 /* void shademodel long s */
6843
6844 static PyObject *
6845 gl_shademodel(self, args)
6846         PyObject *self;
6847         PyObject *args;
6848 {
6849         long arg1 ;
6850         if (!getilongarg(args, 1, 0, &arg1))
6851                 return NULL;
6852         shademodel( arg1 );
6853         Py_INCREF(Py_None);
6854         return Py_None;
6855 }
6856
6857 /* void underlay long s */
6858
6859 static PyObject *
6860 gl_underlay(self, args)
6861         PyObject *self;
6862         PyObject *args;
6863 {
6864         long arg1 ;
6865         if (!getilongarg(args, 1, 0, &arg1))
6866                 return NULL;
6867         underlay( arg1 );
6868         Py_INCREF(Py_None);
6869         return Py_None;
6870 }
6871
6872 /* void bgnclosedline */
6873
6874 static PyObject *
6875 gl_bgnclosedline(self, args)
6876         PyObject *self;
6877         PyObject *args;
6878 {
6879         bgnclosedline( );
6880         Py_INCREF(Py_None);
6881         return Py_None;
6882 }
6883
6884 /* void bgnline */
6885
6886 static PyObject *
6887 gl_bgnline(self, args)
6888         PyObject *self;
6889         PyObject *args;
6890 {
6891         bgnline( );
6892         Py_INCREF(Py_None);
6893         return Py_None;
6894 }
6895
6896 /* void bgnpoint */
6897
6898 static PyObject *
6899 gl_bgnpoint(self, args)
6900         PyObject *self;
6901         PyObject *args;
6902 {
6903         bgnpoint( );
6904         Py_INCREF(Py_None);
6905         return Py_None;
6906 }
6907
6908 /* void bgnpolygon */
6909
6910 static PyObject *
6911 gl_bgnpolygon(self, args)
6912         PyObject *self;
6913         PyObject *args;
6914 {
6915         bgnpolygon( );
6916         Py_INCREF(Py_None);
6917         return Py_None;
6918 }
6919
6920 /* void bgnsurface */
6921
6922 static PyObject *
6923 gl_bgnsurface(self, args)
6924         PyObject *self;
6925         PyObject *args;
6926 {
6927         bgnsurface( );
6928         Py_INCREF(Py_None);
6929         return Py_None;
6930 }
6931
6932 /* void bgntmesh */
6933
6934 static PyObject *
6935 gl_bgntmesh(self, args)
6936         PyObject *self;
6937         PyObject *args;
6938 {
6939         bgntmesh( );
6940         Py_INCREF(Py_None);
6941         return Py_None;
6942 }
6943
6944 /* void bgntrim */
6945
6946 static PyObject *
6947 gl_bgntrim(self, args)
6948         PyObject *self;
6949         PyObject *args;
6950 {
6951         bgntrim( );
6952         Py_INCREF(Py_None);
6953         return Py_None;
6954 }
6955
6956 /* void endclosedline */
6957
6958 static PyObject *
6959 gl_endclosedline(self, args)
6960         PyObject *self;
6961         PyObject *args;
6962 {
6963         endclosedline( );
6964         Py_INCREF(Py_None);
6965         return Py_None;
6966 }
6967
6968 /* void endline */
6969
6970 static PyObject *
6971 gl_endline(self, args)
6972         PyObject *self;
6973         PyObject *args;
6974 {
6975         endline( );
6976         Py_INCREF(Py_None);
6977         return Py_None;
6978 }
6979
6980 /* void endpoint */
6981
6982 static PyObject *
6983 gl_endpoint(self, args)
6984         PyObject *self;
6985         PyObject *args;
6986 {
6987         endpoint( );
6988         Py_INCREF(Py_None);
6989         return Py_None;
6990 }
6991
6992 /* void endpolygon */
6993
6994 static PyObject *
6995 gl_endpolygon(self, args)
6996         PyObject *self;
6997         PyObject *args;
6998 {
6999         endpolygon( );
7000         Py_INCREF(Py_None);
7001         return Py_None;
7002 }
7003
7004 /* void endsurface */
7005
7006 static PyObject *
7007 gl_endsurface(self, args)
7008         PyObject *self;
7009         PyObject *args;
7010 {
7011         endsurface( );
7012         Py_INCREF(Py_None);
7013         return Py_None;
7014 }
7015
7016 /* void endtmesh */
7017
7018 static PyObject *
7019 gl_endtmesh(self, args)
7020         PyObject *self;
7021         PyObject *args;
7022 {
7023         endtmesh( );
7024         Py_INCREF(Py_None);
7025         return Py_None;
7026 }
7027
7028 /* void endtrim */
7029
7030 static PyObject *
7031 gl_endtrim(self, args)
7032         PyObject *self;
7033         PyObject *args;
7034 {
7035         endtrim( );
7036         Py_INCREF(Py_None);
7037         return Py_None;
7038 }
7039
7040 /* void blendfunction long s long s */
7041
7042 static PyObject *
7043 gl_blendfunction(self, args)
7044         PyObject *self;
7045         PyObject *args;
7046 {
7047         long arg1 ;
7048         long arg2 ;
7049         if (!getilongarg(args, 2, 0, &arg1))
7050                 return NULL;
7051         if (!getilongarg(args, 2, 1, &arg2))
7052                 return NULL;
7053         blendfunction( arg1 , arg2 );
7054         Py_INCREF(Py_None);
7055         return Py_None;
7056 }
7057
7058 /* void c3f float s[3] */
7059
7060 static PyObject *
7061 gl_c3f(self, args)
7062         PyObject *self;
7063         PyObject *args;
7064 {
7065         float arg1 [ 3 ] ;
7066         if (!getifloatarray(args, 1, 0, 3 , arg1))
7067                 return NULL;
7068         c3f( arg1 );
7069         Py_INCREF(Py_None);
7070         return Py_None;
7071 }
7072
7073 /* void c3i long s[3] */
7074
7075 static PyObject *
7076 gl_c3i(self, args)
7077         PyObject *self;
7078         PyObject *args;
7079 {
7080         long arg1 [ 3 ] ;
7081         if (!getilongarray(args, 1, 0, 3 , arg1))
7082                 return NULL;
7083         c3i( arg1 );
7084         Py_INCREF(Py_None);
7085         return Py_None;
7086 }
7087
7088 /* void c3s short s[3] */
7089
7090 static PyObject *
7091 gl_c3s(self, args)
7092         PyObject *self;
7093         PyObject *args;
7094 {
7095         short arg1 [ 3 ] ;
7096         if (!getishortarray(args, 1, 0, 3 , arg1))
7097                 return NULL;
7098         c3s( arg1 );
7099         Py_INCREF(Py_None);
7100         return Py_None;
7101 }
7102
7103 /* void c4f float s[4] */
7104
7105 static PyObject *
7106 gl_c4f(self, args)
7107         PyObject *self;
7108         PyObject *args;
7109 {
7110         float arg1 [ 4 ] ;
7111         if (!getifloatarray(args, 1, 0, 4 , arg1))
7112                 return NULL;
7113         c4f( arg1 );
7114         Py_INCREF(Py_None);
7115         return Py_None;
7116 }
7117
7118 /* void c4i long s[4] */
7119
7120 static PyObject *
7121 gl_c4i(self, args)
7122         PyObject *self;
7123         PyObject *args;
7124 {
7125         long arg1 [ 4 ] ;
7126         if (!getilongarray(args, 1, 0, 4 , arg1))
7127                 return NULL;
7128         c4i( arg1 );
7129         Py_INCREF(Py_None);
7130         return Py_None;
7131 }
7132
7133 /* void c4s short s[4] */
7134
7135 static PyObject *
7136 gl_c4s(self, args)
7137         PyObject *self;
7138         PyObject *args;
7139 {
7140         short arg1 [ 4 ] ;
7141         if (!getishortarray(args, 1, 0, 4 , arg1))
7142                 return NULL;
7143         c4s( arg1 );
7144         Py_INCREF(Py_None);
7145         return Py_None;
7146 }
7147
7148 /* void colorf float s */
7149
7150 static PyObject *
7151 gl_colorf(self, args)
7152         PyObject *self;
7153         PyObject *args;
7154 {
7155         float arg1 ;
7156         if (!getifloatarg(args, 1, 0, &arg1))
7157                 return NULL;
7158         colorf( arg1 );
7159         Py_INCREF(Py_None);
7160         return Py_None;
7161 }
7162
7163 /* void cpack long s */
7164
7165 static PyObject *
7166 gl_cpack(self, args)
7167         PyObject *self;
7168         PyObject *args;
7169 {
7170         long arg1 ;
7171         if (!getilongarg(args, 1, 0, &arg1))
7172                 return NULL;
7173         cpack( arg1 );
7174         Py_INCREF(Py_None);
7175         return Py_None;
7176 }
7177
7178 /* void czclear long s long s */
7179
7180 static PyObject *
7181 gl_czclear(self, args)
7182         PyObject *self;
7183         PyObject *args;
7184 {
7185         long arg1 ;
7186         long arg2 ;
7187         if (!getilongarg(args, 2, 0, &arg1))
7188                 return NULL;
7189         if (!getilongarg(args, 2, 1, &arg2))
7190                 return NULL;
7191         czclear( arg1 , arg2 );
7192         Py_INCREF(Py_None);
7193         return Py_None;
7194 }
7195
7196 /* void dglclose long s */
7197
7198 static PyObject *
7199 gl_dglclose(self, args)
7200         PyObject *self;
7201         PyObject *args;
7202 {
7203         long arg1 ;
7204         if (!getilongarg(args, 1, 0, &arg1))
7205                 return NULL;
7206         dglclose( arg1 );
7207         Py_INCREF(Py_None);
7208         return Py_None;
7209 }
7210
7211 /* long dglopen char *s long s */
7212
7213 static PyObject *
7214 gl_dglopen(self, args)
7215         PyObject *self;
7216         PyObject *args;
7217 {
7218         long retval;
7219         string arg1 ;
7220         long arg2 ;
7221         if (!getistringarg(args, 2, 0, &arg1))
7222                 return NULL;
7223         if (!getilongarg(args, 2, 1, &arg2))
7224                 return NULL;
7225         retval = dglopen( arg1 , arg2 );
7226         return mknewlongobject(retval);
7227 }
7228
7229 /* long getgdesc long s */
7230
7231 static PyObject *
7232 gl_getgdesc(self, args)
7233         PyObject *self;
7234         PyObject *args;
7235 {
7236         long retval;
7237         long arg1 ;
7238         if (!getilongarg(args, 1, 0, &arg1))
7239                 return NULL;
7240         retval = getgdesc( arg1 );
7241         return mknewlongobject(retval);
7242 }
7243
7244 /* void getnurbsproperty long s float r */
7245
7246 static PyObject *
7247 gl_getnurbsproperty(self, args)
7248         PyObject *self;
7249         PyObject *args;
7250 {
7251         long arg1 ;
7252         float arg2 ;
7253         if (!getilongarg(args, 1, 0, &arg1))
7254                 return NULL;
7255         getnurbsproperty( arg1 , & arg2 );
7256         return mknewfloatobject(arg2);
7257 }
7258
7259 /* void glcompat long s long s */
7260
7261 static PyObject *
7262 gl_glcompat(self, args)
7263         PyObject *self;
7264         PyObject *args;
7265 {
7266         long arg1 ;
7267         long arg2 ;
7268         if (!getilongarg(args, 2, 0, &arg1))
7269                 return NULL;
7270         if (!getilongarg(args, 2, 1, &arg2))
7271                 return NULL;
7272         glcompat( arg1 , arg2 );
7273         Py_INCREF(Py_None);
7274         return Py_None;
7275 }
7276
7277 /* void iconsize long s long s */
7278
7279 static PyObject *
7280 gl_iconsize(self, args)
7281         PyObject *self;
7282         PyObject *args;
7283 {
7284         long arg1 ;
7285         long arg2 ;
7286         if (!getilongarg(args, 2, 0, &arg1))
7287                 return NULL;
7288         if (!getilongarg(args, 2, 1, &arg2))
7289                 return NULL;
7290         iconsize( arg1 , arg2 );
7291         Py_INCREF(Py_None);
7292         return Py_None;
7293 }
7294
7295 /* void icontitle char *s */
7296
7297 static PyObject *
7298 gl_icontitle(self, args)
7299         PyObject *self;
7300         PyObject *args;
7301 {
7302         string arg1 ;
7303         if (!getistringarg(args, 1, 0, &arg1))
7304                 return NULL;
7305         icontitle( arg1 );
7306         Py_INCREF(Py_None);
7307         return Py_None;
7308 }
7309
7310 /* void lRGBrange short s short s short s short s short s short s long s long s */
7311
7312 static PyObject *
7313 gl_lRGBrange(self, args)
7314         PyObject *self;
7315         PyObject *args;
7316 {
7317         short arg1 ;
7318         short arg2 ;
7319         short arg3 ;
7320         short arg4 ;
7321         short arg5 ;
7322         short arg6 ;
7323         long arg7 ;
7324         long arg8 ;
7325         if (!getishortarg(args, 8, 0, &arg1))
7326                 return NULL;
7327         if (!getishortarg(args, 8, 1, &arg2))
7328                 return NULL;
7329         if (!getishortarg(args, 8, 2, &arg3))
7330                 return NULL;
7331         if (!getishortarg(args, 8, 3, &arg4))
7332                 return NULL;
7333         if (!getishortarg(args, 8, 4, &arg5))
7334                 return NULL;
7335         if (!getishortarg(args, 8, 5, &arg6))
7336                 return NULL;
7337         if (!getilongarg(args, 8, 6, &arg7))
7338                 return NULL;
7339         if (!getilongarg(args, 8, 7, &arg8))
7340                 return NULL;
7341         lRGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 );
7342         Py_INCREF(Py_None);
7343         return Py_None;
7344 }
7345
7346 /* void linesmooth long s */
7347
7348 static PyObject *
7349 gl_linesmooth(self, args)
7350         PyObject *self;
7351         PyObject *args;
7352 {
7353         long arg1 ;
7354         if (!getilongarg(args, 1, 0, &arg1))
7355                 return NULL;
7356         linesmooth( arg1 );
7357         Py_INCREF(Py_None);
7358         return Py_None;
7359 }
7360
7361 /* void lmcolor long s */
7362
7363 static PyObject *
7364 gl_lmcolor(self, args)
7365         PyObject *self;
7366         PyObject *args;
7367 {
7368         long arg1 ;
7369         if (!getilongarg(args, 1, 0, &arg1))
7370                 return NULL;
7371         lmcolor( arg1 );
7372         Py_INCREF(Py_None);
7373         return Py_None;
7374 }
7375
7376 /* void logicop long s */
7377
7378 static PyObject *
7379 gl_logicop(self, args)
7380         PyObject *self;
7381         PyObject *args;
7382 {
7383         long arg1 ;
7384         if (!getilongarg(args, 1, 0, &arg1))
7385                 return NULL;
7386         logicop( arg1 );
7387         Py_INCREF(Py_None);
7388         return Py_None;
7389 }
7390
7391 /* void lsetdepth long s long s */
7392
7393 static PyObject *
7394 gl_lsetdepth(self, args)
7395         PyObject *self;
7396         PyObject *args;
7397 {
7398         long arg1 ;
7399         long arg2 ;
7400         if (!getilongarg(args, 2, 0, &arg1))
7401                 return NULL;
7402         if (!getilongarg(args, 2, 1, &arg2))
7403                 return NULL;
7404         lsetdepth( arg1 , arg2 );
7405         Py_INCREF(Py_None);
7406         return Py_None;
7407 }
7408
7409 /* void lshaderange short s short s long s long s */
7410
7411 static PyObject *
7412 gl_lshaderange(self, args)
7413         PyObject *self;
7414         PyObject *args;
7415 {
7416         short arg1 ;
7417         short arg2 ;
7418         long arg3 ;
7419         long arg4 ;
7420         if (!getishortarg(args, 4, 0, &arg1))
7421                 return NULL;
7422         if (!getishortarg(args, 4, 1, &arg2))
7423                 return NULL;
7424         if (!getilongarg(args, 4, 2, &arg3))
7425                 return NULL;
7426         if (!getilongarg(args, 4, 3, &arg4))
7427                 return NULL;
7428         lshaderange( arg1 , arg2 , arg3 , arg4 );
7429         Py_INCREF(Py_None);
7430         return Py_None;
7431 }
7432
7433 /* void n3f float s[3] */
7434
7435 static PyObject *
7436 gl_n3f(self, args)
7437         PyObject *self;
7438         PyObject *args;
7439 {
7440         float arg1 [ 3 ] ;
7441         if (!getifloatarray(args, 1, 0, 3 , arg1))
7442                 return NULL;
7443         n3f( arg1 );
7444         Py_INCREF(Py_None);
7445         return Py_None;
7446 }
7447
7448 /* void noborder */
7449
7450 static PyObject *
7451 gl_noborder(self, args)
7452         PyObject *self;
7453         PyObject *args;
7454 {
7455         noborder( );
7456         Py_INCREF(Py_None);
7457         return Py_None;
7458 }
7459
7460 /* void pntsmooth long s */
7461
7462 static PyObject *
7463 gl_pntsmooth(self, args)
7464         PyObject *self;
7465         PyObject *args;
7466 {
7467         long arg1 ;
7468         if (!getilongarg(args, 1, 0, &arg1))
7469                 return NULL;
7470         pntsmooth( arg1 );
7471         Py_INCREF(Py_None);
7472         return Py_None;
7473 }
7474
7475 /* void readsource long s */
7476
7477 static PyObject *
7478 gl_readsource(self, args)
7479         PyObject *self;
7480         PyObject *args;
7481 {
7482         long arg1 ;
7483         if (!getilongarg(args, 1, 0, &arg1))
7484                 return NULL;
7485         readsource( arg1 );
7486         Py_INCREF(Py_None);
7487         return Py_None;
7488 }
7489
7490 /* void rectzoom float s float s */
7491
7492 static PyObject *
7493 gl_rectzoom(self, args)
7494         PyObject *self;
7495         PyObject *args;
7496 {
7497         float arg1 ;
7498         float arg2 ;
7499         if (!getifloatarg(args, 2, 0, &arg1))
7500                 return NULL;
7501         if (!getifloatarg(args, 2, 1, &arg2))
7502                 return NULL;
7503         rectzoom( arg1 , arg2 );
7504         Py_INCREF(Py_None);
7505         return Py_None;
7506 }
7507
7508 /* void sbox float s float s float s float s */
7509
7510 static PyObject *
7511 gl_sbox(self, args)
7512         PyObject *self;
7513         PyObject *args;
7514 {
7515         float arg1 ;
7516         float arg2 ;
7517         float arg3 ;
7518         float arg4 ;
7519         if (!getifloatarg(args, 4, 0, &arg1))
7520                 return NULL;
7521         if (!getifloatarg(args, 4, 1, &arg2))
7522                 return NULL;
7523         if (!getifloatarg(args, 4, 2, &arg3))
7524                 return NULL;
7525         if (!getifloatarg(args, 4, 3, &arg4))
7526                 return NULL;
7527         sbox( arg1 , arg2 , arg3 , arg4 );
7528         Py_INCREF(Py_None);
7529         return Py_None;
7530 }
7531
7532 /* void sboxi long s long s long s long s */
7533
7534 static PyObject *
7535 gl_sboxi(self, args)
7536         PyObject *self;
7537         PyObject *args;
7538 {
7539         long arg1 ;
7540         long arg2 ;
7541         long arg3 ;
7542         long arg4 ;
7543         if (!getilongarg(args, 4, 0, &arg1))
7544                 return NULL;
7545         if (!getilongarg(args, 4, 1, &arg2))
7546                 return NULL;
7547         if (!getilongarg(args, 4, 2, &arg3))
7548                 return NULL;
7549         if (!getilongarg(args, 4, 3, &arg4))
7550                 return NULL;
7551         sboxi( arg1 , arg2 , arg3 , arg4 );
7552         Py_INCREF(Py_None);
7553         return Py_None;
7554 }
7555
7556 /* void sboxs short s short s short s short s */
7557
7558 static PyObject *
7559 gl_sboxs(self, args)
7560         PyObject *self;
7561         PyObject *args;
7562 {
7563         short arg1 ;
7564         short arg2 ;
7565         short arg3 ;
7566         short arg4 ;
7567         if (!getishortarg(args, 4, 0, &arg1))
7568                 return NULL;
7569         if (!getishortarg(args, 4, 1, &arg2))
7570                 return NULL;
7571         if (!getishortarg(args, 4, 2, &arg3))
7572                 return NULL;
7573         if (!getishortarg(args, 4, 3, &arg4))
7574                 return NULL;
7575         sboxs( arg1 , arg2 , arg3 , arg4 );
7576         Py_INCREF(Py_None);
7577         return Py_None;
7578 }
7579
7580 /* void sboxf float s float s float s float s */
7581
7582 static PyObject *
7583 gl_sboxf(self, args)
7584         PyObject *self;
7585         PyObject *args;
7586 {
7587         float arg1 ;
7588         float arg2 ;
7589         float arg3 ;
7590         float arg4 ;
7591         if (!getifloatarg(args, 4, 0, &arg1))
7592                 return NULL;
7593         if (!getifloatarg(args, 4, 1, &arg2))
7594                 return NULL;
7595         if (!getifloatarg(args, 4, 2, &arg3))
7596                 return NULL;
7597         if (!getifloatarg(args, 4, 3, &arg4))
7598                 return NULL;
7599         sboxf( arg1 , arg2 , arg3 , arg4 );
7600         Py_INCREF(Py_None);
7601         return Py_None;
7602 }
7603
7604 /* void sboxfi long s long s long s long s */
7605
7606 static PyObject *
7607 gl_sboxfi(self, args)
7608         PyObject *self;
7609         PyObject *args;
7610 {
7611         long arg1 ;
7612         long arg2 ;
7613         long arg3 ;
7614         long arg4 ;
7615         if (!getilongarg(args, 4, 0, &arg1))
7616                 return NULL;
7617         if (!getilongarg(args, 4, 1, &arg2))
7618                 return NULL;
7619         if (!getilongarg(args, 4, 2, &arg3))
7620                 return NULL;
7621         if (!getilongarg(args, 4, 3, &arg4))
7622                 return NULL;
7623         sboxfi( arg1 , arg2 , arg3 , arg4 );
7624         Py_INCREF(Py_None);
7625         return Py_None;
7626 }
7627
7628 /* void sboxfs short s short s short s short s */
7629
7630 static PyObject *
7631 gl_sboxfs(self, args)
7632         PyObject *self;
7633         PyObject *args;
7634 {
7635         short arg1 ;
7636         short arg2 ;
7637         short arg3 ;
7638         short arg4 ;
7639         if (!getishortarg(args, 4, 0, &arg1))
7640                 return NULL;
7641         if (!getishortarg(args, 4, 1, &arg2))
7642                 return NULL;
7643         if (!getishortarg(args, 4, 2, &arg3))
7644                 return NULL;
7645         if (!getishortarg(args, 4, 3, &arg4))
7646                 return NULL;
7647         sboxfs( arg1 , arg2 , arg3 , arg4 );
7648         Py_INCREF(Py_None);
7649         return Py_None;
7650 }
7651
7652 /* void setnurbsproperty long s float s */
7653
7654 static PyObject *
7655 gl_setnurbsproperty(self, args)
7656         PyObject *self;
7657         PyObject *args;
7658 {
7659         long arg1 ;
7660         float arg2 ;
7661         if (!getilongarg(args, 2, 0, &arg1))
7662                 return NULL;
7663         if (!getifloatarg(args, 2, 1, &arg2))
7664                 return NULL;
7665         setnurbsproperty( arg1 , arg2 );
7666         Py_INCREF(Py_None);
7667         return Py_None;
7668 }
7669
7670 /* void setpup long s long s long s */
7671
7672 static PyObject *
7673 gl_setpup(self, args)
7674         PyObject *self;
7675         PyObject *args;
7676 {
7677         long arg1 ;
7678         long arg2 ;
7679         long arg3 ;
7680         if (!getilongarg(args, 3, 0, &arg1))
7681                 return NULL;
7682         if (!getilongarg(args, 3, 1, &arg2))
7683                 return NULL;
7684         if (!getilongarg(args, 3, 2, &arg3))
7685                 return NULL;
7686         setpup( arg1 , arg2 , arg3 );
7687         Py_INCREF(Py_None);
7688         return Py_None;
7689 }
7690
7691 /* void smoothline long s */
7692
7693 static PyObject *
7694 gl_smoothline(self, args)
7695         PyObject *self;
7696         PyObject *args;
7697 {
7698         long arg1 ;
7699         if (!getilongarg(args, 1, 0, &arg1))
7700                 return NULL;
7701         smoothline( arg1 );
7702         Py_INCREF(Py_None);
7703         return Py_None;
7704 }
7705
7706 /* void subpixel long s */
7707
7708 static PyObject *
7709 gl_subpixel(self, args)
7710         PyObject *self;
7711         PyObject *args;
7712 {
7713         long arg1 ;
7714         if (!getilongarg(args, 1, 0, &arg1))
7715                 return NULL;
7716         subpixel( arg1 );
7717         Py_INCREF(Py_None);
7718         return Py_None;
7719 }
7720
7721 /* void swaptmesh */
7722
7723 static PyObject *
7724 gl_swaptmesh(self, args)
7725         PyObject *self;
7726         PyObject *args;
7727 {
7728         swaptmesh( );
7729         Py_INCREF(Py_None);
7730         return Py_None;
7731 }
7732
7733 /* long swinopen long s */
7734
7735 static PyObject *
7736 gl_swinopen(self, args)
7737         PyObject *self;
7738         PyObject *args;
7739 {
7740         long retval;
7741         long arg1 ;
7742         if (!getilongarg(args, 1, 0, &arg1))
7743                 return NULL;
7744         retval = swinopen( arg1 );
7745         return mknewlongobject(retval);
7746 }
7747
7748 /* void v2f float s[2] */
7749
7750 static PyObject *
7751 gl_v2f(self, args)
7752         PyObject *self;
7753         PyObject *args;
7754 {
7755         float arg1 [ 2 ] ;
7756         if (!getifloatarray(args, 1, 0, 2 , arg1))
7757                 return NULL;
7758         v2f( arg1 );
7759         Py_INCREF(Py_None);
7760         return Py_None;
7761 }
7762
7763 /* void v2i long s[2] */
7764
7765 static PyObject *
7766 gl_v2i(self, args)
7767         PyObject *self;
7768         PyObject *args;
7769 {
7770         long arg1 [ 2 ] ;
7771         if (!getilongarray(args, 1, 0, 2 , arg1))
7772                 return NULL;
7773         v2i( arg1 );
7774         Py_INCREF(Py_None);
7775         return Py_None;
7776 }
7777
7778 /* void v2s short s[2] */
7779
7780 static PyObject *
7781 gl_v2s(self, args)
7782         PyObject *self;
7783         PyObject *args;
7784 {
7785         short arg1 [ 2 ] ;
7786         if (!getishortarray(args, 1, 0, 2 , arg1))
7787                 return NULL;
7788         v2s( arg1 );
7789         Py_INCREF(Py_None);
7790         return Py_None;
7791 }
7792
7793 /* void v3f float s[3] */
7794
7795 static PyObject *
7796 gl_v3f(self, args)
7797         PyObject *self;
7798         PyObject *args;
7799 {
7800         float arg1 [ 3 ] ;
7801         if (!getifloatarray(args, 1, 0, 3 , arg1))
7802                 return NULL;
7803         v3f( arg1 );
7804         Py_INCREF(Py_None);
7805         return Py_None;
7806 }
7807
7808 /* void v3i long s[3] */
7809
7810 static PyObject *
7811 gl_v3i(self, args)
7812         PyObject *self;
7813         PyObject *args;
7814 {
7815         long arg1 [ 3 ] ;
7816         if (!getilongarray(args, 1, 0, 3 , arg1))
7817                 return NULL;
7818         v3i( arg1 );
7819         Py_INCREF(Py_None);
7820         return Py_None;
7821 }
7822
7823 /* void v3s short s[3] */
7824
7825 static PyObject *
7826 gl_v3s(self, args)
7827         PyObject *self;
7828         PyObject *args;
7829 {
7830         short arg1 [ 3 ] ;
7831         if (!getishortarray(args, 1, 0, 3 , arg1))
7832                 return NULL;
7833         v3s( arg1 );
7834         Py_INCREF(Py_None);
7835         return Py_None;
7836 }
7837
7838 /* void v4f float s[4] */
7839
7840 static PyObject *
7841 gl_v4f(self, args)
7842         PyObject *self;
7843         PyObject *args;
7844 {
7845         float arg1 [ 4 ] ;
7846         if (!getifloatarray(args, 1, 0, 4 , arg1))
7847                 return NULL;
7848         v4f( arg1 );
7849         Py_INCREF(Py_None);
7850         return Py_None;
7851 }
7852
7853 /* void v4i long s[4] */
7854
7855 static PyObject *
7856 gl_v4i(self, args)
7857         PyObject *self;
7858         PyObject *args;
7859 {
7860         long arg1 [ 4 ] ;
7861         if (!getilongarray(args, 1, 0, 4 , arg1))
7862                 return NULL;
7863         v4i( arg1 );
7864         Py_INCREF(Py_None);
7865         return Py_None;
7866 }
7867
7868 /* void v4s short s[4] */
7869
7870 static PyObject *
7871 gl_v4s(self, args)
7872         PyObject *self;
7873         PyObject *args;
7874 {
7875         short arg1 [ 4 ] ;
7876         if (!getishortarray(args, 1, 0, 4 , arg1))
7877                 return NULL;
7878         v4s( arg1 );
7879         Py_INCREF(Py_None);
7880         return Py_None;
7881 }
7882
7883 /* void videocmd long s */
7884
7885 static PyObject *
7886 gl_videocmd(self, args)
7887         PyObject *self;
7888         PyObject *args;
7889 {
7890         long arg1 ;
7891         if (!getilongarg(args, 1, 0, &arg1))
7892                 return NULL;
7893         videocmd( arg1 );
7894         Py_INCREF(Py_None);
7895         return Py_None;
7896 }
7897
7898 /* long windepth long s */
7899
7900 static PyObject *
7901 gl_windepth(self, args)
7902         PyObject *self;
7903         PyObject *args;
7904 {
7905         long retval;
7906         long arg1 ;
7907         if (!getilongarg(args, 1, 0, &arg1))
7908                 return NULL;
7909         retval = windepth( arg1 );
7910         return mknewlongobject(retval);
7911 }
7912
7913 /* void wmpack long s */
7914
7915 static PyObject *
7916 gl_wmpack(self, args)
7917         PyObject *self;
7918         PyObject *args;
7919 {
7920         long arg1 ;
7921         if (!getilongarg(args, 1, 0, &arg1))
7922                 return NULL;
7923         wmpack( arg1 );
7924         Py_INCREF(Py_None);
7925         return Py_None;
7926 }
7927
7928 /* void zdraw long s */
7929
7930 static PyObject *
7931 gl_zdraw(self, args)
7932         PyObject *self;
7933         PyObject *args;
7934 {
7935         long arg1 ;
7936         if (!getilongarg(args, 1, 0, &arg1))
7937                 return NULL;
7938         zdraw( arg1 );
7939         Py_INCREF(Py_None);
7940         return Py_None;
7941 }
7942
7943 /* void zfunction long s */
7944
7945 static PyObject *
7946 gl_zfunction(self, args)
7947         PyObject *self;
7948         PyObject *args;
7949 {
7950         long arg1 ;
7951         if (!getilongarg(args, 1, 0, &arg1))
7952                 return NULL;
7953         zfunction( arg1 );
7954         Py_INCREF(Py_None);
7955         return Py_None;
7956 }
7957
7958 /* void zsource long s */
7959
7960 static PyObject *
7961 gl_zsource(self, args)
7962         PyObject *self;
7963         PyObject *args;
7964 {
7965         long arg1 ;
7966         if (!getilongarg(args, 1, 0, &arg1))
7967                 return NULL;
7968         zsource( arg1 );
7969         Py_INCREF(Py_None);
7970         return Py_None;
7971 }
7972
7973 /* void zwritemask long s */
7974
7975 static PyObject *
7976 gl_zwritemask(self, args)
7977         PyObject *self;
7978         PyObject *args;
7979 {
7980         long arg1 ;
7981         if (!getilongarg(args, 1, 0, &arg1))
7982                 return NULL;
7983         zwritemask( arg1 );
7984         Py_INCREF(Py_None);
7985         return Py_None;
7986 }
7987
7988 /* void v2d double s[2] */
7989
7990 static PyObject *
7991 gl_v2d(self, args)
7992         PyObject *self;
7993         PyObject *args;
7994 {
7995         double arg1 [ 2 ] ;
7996         if (!getidoublearray(args, 1, 0, 2 , arg1))
7997                 return NULL;
7998         v2d( arg1 );
7999         Py_INCREF(Py_None);
8000         return Py_None;
8001 }
8002
8003 /* void v3d double s[3] */
8004
8005 static PyObject *
8006 gl_v3d(self, args)
8007         PyObject *self;
8008         PyObject *args;
8009 {
8010         double arg1 [ 3 ] ;
8011         if (!getidoublearray(args, 1, 0, 3 , arg1))
8012                 return NULL;
8013         v3d( arg1 );
8014         Py_INCREF(Py_None);
8015         return Py_None;
8016 }
8017
8018 /* void v4d double s[4] */
8019
8020 static PyObject *
8021 gl_v4d(self, args)
8022         PyObject *self;
8023         PyObject *args;
8024 {
8025         double arg1 [ 4 ] ;
8026         if (!getidoublearray(args, 1, 0, 4 , arg1))
8027                 return NULL;
8028         v4d( arg1 );
8029         Py_INCREF(Py_None);
8030         return Py_None;
8031 }
8032
8033 /* void pixmode long s long s */
8034
8035 static PyObject *
8036 gl_pixmode(self, args)
8037         PyObject *self;
8038         PyObject *args;
8039 {
8040         long arg1 ;
8041         long arg2 ;
8042         if (!getilongarg(args, 2, 0, &arg1))
8043                 return NULL;
8044         if (!getilongarg(args, 2, 1, &arg2))
8045                 return NULL;
8046         pixmode( arg1 , arg2 );
8047         Py_INCREF(Py_None);
8048         return Py_None;
8049 }
8050
8051 /* long qgetfd */
8052
8053 static PyObject *
8054 gl_qgetfd(self, args)
8055         PyObject *self;
8056         PyObject *args;
8057 {
8058         long retval;
8059         retval = qgetfd( );
8060         return mknewlongobject(retval);
8061 }
8062
8063 /* void dither long s */
8064
8065 static PyObject *
8066 gl_dither(self, args)
8067         PyObject *self;
8068         PyObject *args;
8069 {
8070         long arg1 ;
8071         if (!getilongarg(args, 1, 0, &arg1))
8072                 return NULL;
8073         dither( arg1 );
8074         Py_INCREF(Py_None);
8075         return Py_None;
8076 }
8077
8078 static struct PyMethodDef gl_methods[] = {
8079         {"qread", gl_qread},
8080         {"varray", gl_varray},
8081         {"nvarray", gl_nvarray},
8082         {"vnarray", gl_vnarray},
8083         {"nurbssurface", gl_nurbssurface},
8084         {"nurbscurve", gl_nurbscurve},
8085         {"pwlcurve", gl_pwlcurve},
8086         {"pick", gl_pick},
8087         {"endpick", gl_endpick},
8088         {"gselect", gl_gselect},
8089         {"endselect", gl_endselect},
8090         {"getmatrix", gl_getmatrix},
8091         {"altgetmatrix", gl_altgetmatrix},
8092         {"lrectwrite", gl_lrectwrite},
8093         {"lrectread", gl_lrectread},
8094         {"readdisplay", gl_readdisplay},
8095         {"packrect", gl_packrect},
8096         {"unpackrect", gl_unpackrect},
8097         {"gversion", gl_gversion},
8098         {"clear", gl_clear},
8099         {"getshade", gl_getshade},
8100         {"devport", gl_devport},
8101         {"rdr2i", gl_rdr2i},
8102         {"rectfs", gl_rectfs},
8103         {"rects", gl_rects},
8104         {"rmv2i", gl_rmv2i},
8105         {"noport", gl_noport},
8106         {"popviewport", gl_popviewport},
8107         {"clearhitcode", gl_clearhitcode},
8108         {"closeobj", gl_closeobj},
8109         {"cursoff", gl_cursoff},
8110         {"curson", gl_curson},
8111         {"doublebuffer", gl_doublebuffer},
8112         {"finish", gl_finish},
8113         {"gconfig", gl_gconfig},
8114         {"ginit", gl_ginit},
8115         {"greset", gl_greset},
8116         {"multimap", gl_multimap},
8117         {"onemap", gl_onemap},
8118         {"popattributes", gl_popattributes},
8119         {"popmatrix", gl_popmatrix},
8120         {"pushattributes", gl_pushattributes},
8121         {"pushmatrix", gl_pushmatrix},
8122         {"pushviewport", gl_pushviewport},
8123         {"qreset", gl_qreset},
8124         {"RGBmode", gl_RGBmode},
8125         {"singlebuffer", gl_singlebuffer},
8126         {"swapbuffers", gl_swapbuffers},
8127         {"gsync", gl_gsync},
8128         {"gflush", gl_gflush},
8129         {"tpon", gl_tpon},
8130         {"tpoff", gl_tpoff},
8131         {"clkon", gl_clkon},
8132         {"clkoff", gl_clkoff},
8133         {"ringbell", gl_ringbell},
8134         {"gbegin", gl_gbegin},
8135         {"textinit", gl_textinit},
8136         {"initnames", gl_initnames},
8137         {"pclos", gl_pclos},
8138         {"popname", gl_popname},
8139         {"spclos", gl_spclos},
8140         {"zclear", gl_zclear},
8141         {"screenspace", gl_screenspace},
8142         {"reshapeviewport", gl_reshapeviewport},
8143         {"winpush", gl_winpush},
8144         {"winpop", gl_winpop},
8145         {"foreground", gl_foreground},
8146         {"endfullscrn", gl_endfullscrn},
8147         {"endpupmode", gl_endpupmode},
8148         {"fullscrn", gl_fullscrn},
8149         {"pupmode", gl_pupmode},
8150         {"winconstraints", gl_winconstraints},
8151         {"pagecolor", gl_pagecolor},
8152         {"textcolor", gl_textcolor},
8153         {"color", gl_color},
8154         {"curveit", gl_curveit},
8155         {"font", gl_font},
8156         {"linewidth", gl_linewidth},
8157         {"setlinestyle", gl_setlinestyle},
8158         {"setmap", gl_setmap},
8159         {"swapinterval", gl_swapinterval},
8160         {"writemask", gl_writemask},
8161         {"textwritemask", gl_textwritemask},
8162         {"qdevice", gl_qdevice},
8163         {"unqdevice", gl_unqdevice},
8164         {"curvebasis", gl_curvebasis},
8165         {"curveprecision", gl_curveprecision},
8166         {"loadname", gl_loadname},
8167         {"passthrough", gl_passthrough},
8168         {"pushname", gl_pushname},
8169         {"setmonitor", gl_setmonitor},
8170         {"setshade", gl_setshade},
8171         {"setpattern", gl_setpattern},
8172         {"pagewritemask", gl_pagewritemask},
8173         {"callobj", gl_callobj},
8174         {"delobj", gl_delobj},
8175         {"editobj", gl_editobj},
8176         {"makeobj", gl_makeobj},
8177         {"maketag", gl_maketag},
8178         {"chunksize", gl_chunksize},
8179         {"compactify", gl_compactify},
8180         {"deltag", gl_deltag},
8181         {"lsrepeat", gl_lsrepeat},
8182         {"objinsert", gl_objinsert},
8183         {"objreplace", gl_objreplace},
8184         {"winclose", gl_winclose},
8185         {"blanktime", gl_blanktime},
8186         {"freepup", gl_freepup},
8187         {"backbuffer", gl_backbuffer},
8188         {"frontbuffer", gl_frontbuffer},
8189         {"lsbackup", gl_lsbackup},
8190         {"resetls", gl_resetls},
8191         {"lampon", gl_lampon},
8192         {"lampoff", gl_lampoff},
8193         {"setbell", gl_setbell},
8194         {"blankscreen", gl_blankscreen},
8195         {"depthcue", gl_depthcue},
8196         {"zbuffer", gl_zbuffer},
8197         {"backface", gl_backface},
8198         {"cmov2i", gl_cmov2i},
8199         {"draw2i", gl_draw2i},
8200         {"move2i", gl_move2i},
8201         {"pnt2i", gl_pnt2i},
8202         {"patchbasis", gl_patchbasis},
8203         {"patchprecision", gl_patchprecision},
8204         {"pdr2i", gl_pdr2i},
8205         {"pmv2i", gl_pmv2i},
8206         {"rpdr2i", gl_rpdr2i},
8207         {"rpmv2i", gl_rpmv2i},
8208         {"xfpt2i", gl_xfpt2i},
8209         {"objdelete", gl_objdelete},
8210         {"patchcurves", gl_patchcurves},
8211         {"minsize", gl_minsize},
8212         {"maxsize", gl_maxsize},
8213         {"keepaspect", gl_keepaspect},
8214         {"prefsize", gl_prefsize},
8215         {"stepunit", gl_stepunit},
8216         {"fudge", gl_fudge},
8217         {"winmove", gl_winmove},
8218         {"attachcursor", gl_attachcursor},
8219         {"deflinestyle", gl_deflinestyle},
8220         {"noise", gl_noise},
8221         {"picksize", gl_picksize},
8222         {"qenter", gl_qenter},
8223         {"setdepth", gl_setdepth},
8224         {"cmov2s", gl_cmov2s},
8225         {"draw2s", gl_draw2s},
8226         {"move2s", gl_move2s},
8227         {"pdr2s", gl_pdr2s},
8228         {"pmv2s", gl_pmv2s},
8229         {"pnt2s", gl_pnt2s},
8230         {"rdr2s", gl_rdr2s},
8231         {"rmv2s", gl_rmv2s},
8232         {"rpdr2s", gl_rpdr2s},
8233         {"rpmv2s", gl_rpmv2s},
8234         {"xfpt2s", gl_xfpt2s},
8235         {"cmov2", gl_cmov2},
8236         {"draw2", gl_draw2},
8237         {"move2", gl_move2},
8238         {"pnt2", gl_pnt2},
8239         {"pdr2", gl_pdr2},
8240         {"pmv2", gl_pmv2},
8241         {"rdr2", gl_rdr2},
8242         {"rmv2", gl_rmv2},
8243         {"rpdr2", gl_rpdr2},
8244         {"rpmv2", gl_rpmv2},
8245         {"xfpt2", gl_xfpt2},
8246         {"loadmatrix", gl_loadmatrix},
8247         {"multmatrix", gl_multmatrix},
8248         {"crv", gl_crv},
8249         {"rcrv", gl_rcrv},
8250         {"addtopup", gl_addtopup},
8251         {"charstr", gl_charstr},
8252         {"getport", gl_getport},
8253         {"strwidth", gl_strwidth},
8254         {"winopen", gl_winopen},
8255         {"wintitle", gl_wintitle},
8256         {"polf", gl_polf},
8257         {"polf2", gl_polf2},
8258         {"poly", gl_poly},
8259         {"poly2", gl_poly2},
8260         {"crvn", gl_crvn},
8261         {"rcrvn", gl_rcrvn},
8262         {"polf2i", gl_polf2i},
8263         {"polfi", gl_polfi},
8264         {"poly2i", gl_poly2i},
8265         {"polyi", gl_polyi},
8266         {"polf2s", gl_polf2s},
8267         {"polfs", gl_polfs},
8268         {"polys", gl_polys},
8269         {"poly2s", gl_poly2s},
8270         {"defcursor", gl_defcursor},
8271         {"writepixels", gl_writepixels},
8272         {"defbasis", gl_defbasis},
8273         {"gewrite", gl_gewrite},
8274         {"rotate", gl_rotate},
8275         {"rot", gl_rot},
8276         {"circfi", gl_circfi},
8277         {"circi", gl_circi},
8278         {"cmovi", gl_cmovi},
8279         {"drawi", gl_drawi},
8280         {"movei", gl_movei},
8281         {"pnti", gl_pnti},
8282         {"newtag", gl_newtag},
8283         {"pdri", gl_pdri},
8284         {"pmvi", gl_pmvi},
8285         {"rdri", gl_rdri},
8286         {"rmvi", gl_rmvi},
8287         {"rpdri", gl_rpdri},
8288         {"rpmvi", gl_rpmvi},
8289         {"xfpti", gl_xfpti},
8290         {"circ", gl_circ},
8291         {"circf", gl_circf},
8292         {"cmov", gl_cmov},
8293         {"draw", gl_draw},
8294         {"move", gl_move},
8295         {"pnt", gl_pnt},
8296         {"scale", gl_scale},
8297         {"translate", gl_translate},
8298         {"pdr", gl_pdr},
8299         {"pmv", gl_pmv},
8300         {"rdr", gl_rdr},
8301         {"rmv", gl_rmv},
8302         {"rpdr", gl_rpdr},
8303         {"rpmv", gl_rpmv},
8304         {"xfpt", gl_xfpt},
8305         {"RGBcolor", gl_RGBcolor},
8306         {"RGBwritemask", gl_RGBwritemask},
8307         {"setcursor", gl_setcursor},
8308         {"tie", gl_tie},
8309         {"circfs", gl_circfs},
8310         {"circs", gl_circs},
8311         {"cmovs", gl_cmovs},
8312         {"draws", gl_draws},
8313         {"moves", gl_moves},
8314         {"pdrs", gl_pdrs},
8315         {"pmvs", gl_pmvs},
8316         {"pnts", gl_pnts},
8317         {"rdrs", gl_rdrs},
8318         {"rmvs", gl_rmvs},
8319         {"rpdrs", gl_rpdrs},
8320         {"rpmvs", gl_rpmvs},
8321         {"xfpts", gl_xfpts},
8322         {"curorigin", gl_curorigin},
8323         {"cyclemap", gl_cyclemap},
8324         {"patch", gl_patch},
8325         {"splf", gl_splf},
8326         {"splf2", gl_splf2},
8327         {"splfi", gl_splfi},
8328         {"splf2i", gl_splf2i},
8329         {"splfs", gl_splfs},
8330         {"splf2s", gl_splf2s},
8331         {"rpatch", gl_rpatch},
8332         {"ortho2", gl_ortho2},
8333         {"rect", gl_rect},
8334         {"rectf", gl_rectf},
8335         {"xfpt4", gl_xfpt4},
8336         {"textport", gl_textport},
8337         {"mapcolor", gl_mapcolor},
8338         {"scrmask", gl_scrmask},
8339         {"setvaluator", gl_setvaluator},
8340         {"viewport", gl_viewport},
8341         {"shaderange", gl_shaderange},
8342         {"xfpt4s", gl_xfpt4s},
8343         {"rectfi", gl_rectfi},
8344         {"recti", gl_recti},
8345         {"xfpt4i", gl_xfpt4i},
8346         {"prefposition", gl_prefposition},
8347         {"arc", gl_arc},
8348         {"arcf", gl_arcf},
8349         {"arcfi", gl_arcfi},
8350         {"arci", gl_arci},
8351         {"bbox2", gl_bbox2},
8352         {"bbox2i", gl_bbox2i},
8353         {"bbox2s", gl_bbox2s},
8354         {"blink", gl_blink},
8355         {"ortho", gl_ortho},
8356         {"window", gl_window},
8357         {"lookat", gl_lookat},
8358         {"perspective", gl_perspective},
8359         {"polarview", gl_polarview},
8360         {"arcfs", gl_arcfs},
8361         {"arcs", gl_arcs},
8362         {"rectcopy", gl_rectcopy},
8363         {"RGBcursor", gl_RGBcursor},
8364         {"getbutton", gl_getbutton},
8365         {"getcmmode", gl_getcmmode},
8366         {"getlsbackup", gl_getlsbackup},
8367         {"getresetls", gl_getresetls},
8368         {"getdcm", gl_getdcm},
8369         {"getzbuffer", gl_getzbuffer},
8370         {"ismex", gl_ismex},
8371         {"isobj", gl_isobj},
8372         {"isqueued", gl_isqueued},
8373         {"istag", gl_istag},
8374         {"genobj", gl_genobj},
8375         {"gentag", gl_gentag},
8376         {"getbuffer", gl_getbuffer},
8377         {"getcolor", gl_getcolor},
8378         {"getdisplaymode", gl_getdisplaymode},
8379         {"getfont", gl_getfont},
8380         {"getheight", gl_getheight},
8381         {"gethitcode", gl_gethitcode},
8382         {"getlstyle", gl_getlstyle},
8383         {"getlwidth", gl_getlwidth},
8384         {"getmap", gl_getmap},
8385         {"getplanes", gl_getplanes},
8386         {"getwritemask", gl_getwritemask},
8387         {"qtest", gl_qtest},
8388         {"getlsrepeat", gl_getlsrepeat},
8389         {"getmonitor", gl_getmonitor},
8390         {"getopenobj", gl_getopenobj},
8391         {"getpattern", gl_getpattern},
8392         {"winget", gl_winget},
8393         {"winattach", gl_winattach},
8394         {"getothermonitor", gl_getothermonitor},
8395         {"newpup", gl_newpup},
8396         {"getvaluator", gl_getvaluator},
8397         {"winset", gl_winset},
8398         {"dopup", gl_dopup},
8399         {"getdepth", gl_getdepth},
8400         {"getcpos", gl_getcpos},
8401         {"getsize", gl_getsize},
8402         {"getorigin", gl_getorigin},
8403         {"getviewport", gl_getviewport},
8404         {"gettp", gl_gettp},
8405         {"getgpos", gl_getgpos},
8406         {"winposition", gl_winposition},
8407         {"gRGBcolor", gl_gRGBcolor},
8408         {"gRGBmask", gl_gRGBmask},
8409         {"getscrmask", gl_getscrmask},
8410         {"getmcolor", gl_getmcolor},
8411         {"mapw", gl_mapw},
8412         {"mapw2", gl_mapw2},
8413         {"getcursor", gl_getcursor},
8414         {"cmode", gl_cmode},
8415         {"concave", gl_concave},
8416         {"curstype", gl_curstype},
8417         {"drawmode", gl_drawmode},
8418         {"gammaramp", gl_gammaramp},
8419         {"getbackface", gl_getbackface},
8420         {"getdescender", gl_getdescender},
8421         {"getdrawmode", gl_getdrawmode},
8422         {"getmmode", gl_getmmode},
8423         {"getsm", gl_getsm},
8424         {"getvideo", gl_getvideo},
8425         {"imakebackground", gl_imakebackground},
8426         {"lmbind", gl_lmbind},
8427         {"lmdef", gl_lmdef},
8428         {"mmode", gl_mmode},
8429         {"normal", gl_normal},
8430         {"overlay", gl_overlay},
8431         {"RGBrange", gl_RGBrange},
8432         {"setvideo", gl_setvideo},
8433         {"shademodel", gl_shademodel},
8434         {"underlay", gl_underlay},
8435         {"bgnclosedline", gl_bgnclosedline},
8436         {"bgnline", gl_bgnline},
8437         {"bgnpoint", gl_bgnpoint},
8438         {"bgnpolygon", gl_bgnpolygon},
8439         {"bgnsurface", gl_bgnsurface},
8440         {"bgntmesh", gl_bgntmesh},
8441         {"bgntrim", gl_bgntrim},
8442         {"endclosedline", gl_endclosedline},
8443         {"endline", gl_endline},
8444         {"endpoint", gl_endpoint},
8445         {"endpolygon", gl_endpolygon},
8446         {"endsurface", gl_endsurface},
8447         {"endtmesh", gl_endtmesh},
8448         {"endtrim", gl_endtrim},
8449         {"blendfunction", gl_blendfunction},
8450         {"c3f", gl_c3f},
8451         {"c3i", gl_c3i},
8452         {"c3s", gl_c3s},
8453         {"c4f", gl_c4f},
8454         {"c4i", gl_c4i},
8455         {"c4s", gl_c4s},
8456         {"colorf", gl_colorf},
8457         {"cpack", gl_cpack},
8458         {"czclear", gl_czclear},
8459         {"dglclose", gl_dglclose},
8460         {"dglopen", gl_dglopen},
8461         {"getgdesc", gl_getgdesc},
8462         {"getnurbsproperty", gl_getnurbsproperty},
8463         {"glcompat", gl_glcompat},
8464         {"iconsize", gl_iconsize},
8465         {"icontitle", gl_icontitle},
8466         {"lRGBrange", gl_lRGBrange},
8467         {"linesmooth", gl_linesmooth},
8468         {"lmcolor", gl_lmcolor},
8469         {"logicop", gl_logicop},
8470         {"lsetdepth", gl_lsetdepth},
8471         {"lshaderange", gl_lshaderange},
8472         {"n3f", gl_n3f},
8473         {"noborder", gl_noborder},
8474         {"pntsmooth", gl_pntsmooth},
8475         {"readsource", gl_readsource},
8476         {"rectzoom", gl_rectzoom},
8477         {"sbox", gl_sbox},
8478         {"sboxi", gl_sboxi},
8479         {"sboxs", gl_sboxs},
8480         {"sboxf", gl_sboxf},
8481         {"sboxfi", gl_sboxfi},
8482         {"sboxfs", gl_sboxfs},
8483         {"setnurbsproperty", gl_setnurbsproperty},
8484         {"setpup", gl_setpup},
8485         {"smoothline", gl_smoothline},
8486         {"subpixel", gl_subpixel},
8487         {"swaptmesh", gl_swaptmesh},
8488         {"swinopen", gl_swinopen},
8489         {"v2f", gl_v2f},
8490         {"v2i", gl_v2i},
8491         {"v2s", gl_v2s},
8492         {"v3f", gl_v3f},
8493         {"v3i", gl_v3i},
8494         {"v3s", gl_v3s},
8495         {"v4f", gl_v4f},
8496         {"v4i", gl_v4i},
8497         {"v4s", gl_v4s},
8498         {"videocmd", gl_videocmd},
8499         {"windepth", gl_windepth},
8500         {"wmpack", gl_wmpack},
8501         {"zdraw", gl_zdraw},
8502         {"zfunction", gl_zfunction},
8503         {"zsource", gl_zsource},
8504         {"zwritemask", gl_zwritemask},
8505         {"v2d", gl_v2d},
8506         {"v3d", gl_v3d},
8507         {"v4d", gl_v4d},
8508         {"pixmode", gl_pixmode},
8509         {"qgetfd", gl_qgetfd},
8510         {"dither", gl_dither},
8511         {NULL, NULL} /* Sentinel */
8512 };
8513
8514 void
8515 initgl()
8516 {
8517         (void) Py_InitModule("gl", gl_methods);
8518 }