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