Modules/glmodule.c

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