src/glx/x11/indirect.c

   1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
   2
   3 /*
   4  * (C) Copyright IBM Corporation 2004
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  21  * IBM,
  22  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28
  29 #include <GL/gl.h>
  30 #include "indirect.h"
  31 #include "glxclient.h"
  32 #include "size.h"
  33 #include <GL/glxproto.h>
  34
  35 #define __GLX_PAD(n) (((n) + 3) & ~3)
  36
  37 #  if defined(__i386__) && defined(__GNUC__)
  38 #    define FASTCALL __attribute__((fastcall))
  39 #  else
  40 #    define FASTCALL
  41 #  endif
  42 #  if defined(__GNUC__)
  43 #    define NOINLINE __attribute__((noinline))
  44 #  else
  45 #    define NOINLINE
  46 #  endif
  47
  48 /* If the size and opcode values are known at compile-time, this will, on
  49  * x86 at least, emit them with a single instruction.
  50  */
  51 #define emit_header(dest, op, size)            \
  52     do { union { short s[2]; int i; } temp;    \
  53          temp.s[0] = (size); temp.s[1] = (op); \
  54          *((int *)(dest)) = temp.i; } while(0)
  55
  56 static NOINLINE CARD32
  57 read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
  58 {
  59     xGLXSingleReply reply;
  60
  61     (void) _XReply(dpy, (xReply *) & reply, 0, False);
  62     if (size != 0) {
  63         if ((reply.size >= 1) || reply_is_always_array) {
  64             const GLint bytes = (reply_is_always_array)
  65               ? (4 * reply.length) : (reply.size * size);
  66             const GLint extra = 4 - (bytes & 3);
  67
  68             _XRead(dpy, dest, bytes);
  69             if ( extra != 0 ) {
  70                 _XEatData(dpy, extra);
  71             }
  72         }
  73         else {
  74             (void) memcpy( dest, &(reply.pad3), size);
  75         }
  76     }
  77
  78     return reply.retval;
  79 }
  80
  81 #define X_GLXSingle 0
  82
  83 static NOINLINE GLubyte *
  84 setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
  85 {
  86     xGLXSingleReq * req;
  87     Display * const dpy = gc->currentDpy;
  88
  89     (void) __glXFlushRenderBuffer(gc, gc->pc);
  90     LockDisplay(dpy);
  91     GetReqExtra(GLXSingle, cmdlen, req);
  92     req->reqType = gc->majorOpcode;
  93     req->contextTag = gc->currentContextTag;
  94     req->glxCode = sop;
  95     return (GLubyte *)(req) + sz_xGLXSingleReq;
  96 }
  97
  98 static NOINLINE GLubyte *
  99 setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
 100 {
 101     xGLXVendorPrivateReq * req;
 102     Display * const dpy = gc->currentDpy;
 103
 104     (void) __glXFlushRenderBuffer(gc, gc->pc);
 105     LockDisplay(dpy);
 106     GetReqExtra(GLXVendorPrivate, cmdlen, req);
 107     req->reqType = gc->majorOpcode;
 108     req->glxCode = code;
 109     req->vendorCode = vop;
 110     req->contextTag = gc->currentContextTag;
 111     return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
 112 }
 113
 114 static FASTCALL NOINLINE void
 115 generic_3_byte( GLint rop, const void * ptr )
 116 {
 117     __GLXcontext * const gc = __glXGetCurrentContext();
 118     const GLuint cmdlen = 7;
 119
 120     emit_header(gc->pc, rop, cmdlen);
 121     (void) memcpy((void *)(gc->pc + 4), ptr, 3);
 122     gc->pc += cmdlen;
 123     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 124 }
 125
 126 static FASTCALL NOINLINE void
 127 generic_4_byte( GLint rop, const void * ptr )
 128 {
 129     __GLXcontext * const gc = __glXGetCurrentContext();
 130     const GLuint cmdlen = 8;
 131
 132     emit_header(gc->pc, rop, cmdlen);
 133     (void) memcpy((void *)(gc->pc + 4), ptr, 4);
 134     gc->pc += cmdlen;
 135     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 136 }
 137
 138 static FASTCALL NOINLINE void
 139 generic_6_byte( GLint rop, const void * ptr )
 140 {
 141     __GLXcontext * const gc = __glXGetCurrentContext();
 142     const GLuint cmdlen = 10;
 143
 144     emit_header(gc->pc, rop, cmdlen);
 145     (void) memcpy((void *)(gc->pc + 4), ptr, 6);
 146     gc->pc += cmdlen;
 147     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 148 }
 149
 150 static FASTCALL NOINLINE void
 151 generic_8_byte( GLint rop, const void * ptr )
 152 {
 153     __GLXcontext * const gc = __glXGetCurrentContext();
 154     const GLuint cmdlen = 12;
 155
 156     emit_header(gc->pc, rop, cmdlen);
 157     (void) memcpy((void *)(gc->pc + 4), ptr, 8);
 158     gc->pc += cmdlen;
 159     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 160 }
 161
 162 static FASTCALL NOINLINE void
 163 generic_12_byte( GLint rop, const void * ptr )
 164 {
 165     __GLXcontext * const gc = __glXGetCurrentContext();
 166     const GLuint cmdlen = 16;
 167
 168     emit_header(gc->pc, rop, cmdlen);
 169     (void) memcpy((void *)(gc->pc + 4), ptr, 12);
 170     gc->pc += cmdlen;
 171     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 172 }
 173
 174 static FASTCALL NOINLINE void
 175 generic_16_byte( GLint rop, const void * ptr )
 176 {
 177     __GLXcontext * const gc = __glXGetCurrentContext();
 178     const GLuint cmdlen = 20;
 179
 180     emit_header(gc->pc, rop, cmdlen);
 181     (void) memcpy((void *)(gc->pc + 4), ptr, 16);
 182     gc->pc += cmdlen;
 183     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 184 }
 185
 186 static FASTCALL NOINLINE void
 187 generic_24_byte( GLint rop, const void * ptr )
 188 {
 189     __GLXcontext * const gc = __glXGetCurrentContext();
 190     const GLuint cmdlen = 28;
 191
 192     emit_header(gc->pc, rop, cmdlen);
 193     (void) memcpy((void *)(gc->pc + 4), ptr, 24);
 194     gc->pc += cmdlen;
 195     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 196 }
 197
 198 static FASTCALL NOINLINE void
 199 generic_32_byte( GLint rop, const void * ptr )
 200 {
 201     __GLXcontext * const gc = __glXGetCurrentContext();
 202     const GLuint cmdlen = 36;
 203
 204     emit_header(gc->pc, rop, cmdlen);
 205     (void) memcpy((void *)(gc->pc + 4), ptr, 32);
 206     gc->pc += cmdlen;
 207     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 208 }
 209
 210 #define X_GLsop_NewList 101
 211 void
 212 __indirect_glNewList(GLuint list, GLenum mode)
 213 {
 214     __GLXcontext * const gc = __glXGetCurrentContext();
 215     Display * const dpy = gc->currentDpy;
 216     const GLuint cmdlen = 8;
 217     (void) dpy;
 218     if (dpy != NULL) {
 219         GLubyte const * pc = setup_single_request(gc, X_GLsop_NewList, cmdlen);
 220         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 221         (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
 222         UnlockDisplay(gc->currentDpy); SyncHandle();
 223     }
 224     return;
 225 }
 226
 227 #define X_GLsop_EndList 102
 228 void
 229 __indirect_glEndList(void)
 230 {
 231     __GLXcontext * const gc = __glXGetCurrentContext();
 232     Display * const dpy = gc->currentDpy;
 233     const GLuint cmdlen = 0;
 234     (void) dpy;
 235     if (dpy != NULL) {
 236         (void) setup_single_request(gc, X_GLsop_EndList, cmdlen);
 237         UnlockDisplay(gc->currentDpy); SyncHandle();
 238     }
 239     return;
 240 }
 241
 242 #define X_GLrop_CallList 1
 243 void
 244 __indirect_glCallList(GLuint list)
 245 {
 246     __GLXcontext * const gc = __glXGetCurrentContext();
 247     Display * const dpy = gc->currentDpy;
 248     const GLuint cmdlen = 8;
 249     (void) dpy;
 250     emit_header(gc->pc, X_GLrop_CallList, cmdlen);
 251     (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
 252     gc->pc += cmdlen;
 253     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 254 }
 255
 256 #define X_GLrop_CallLists 2
 257 void
 258 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
 259 {
 260     __GLXcontext * const gc = __glXGetCurrentContext();
 261     Display * const dpy = gc->currentDpy;
 262     const GLuint compsize = __glCallLists_size(type);
 263     const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
 264     if (dpy == NULL) return;
 265     if ( ((gc->pc + cmdlen) > gc->bufEnd)
 266          || (cmdlen > gc->maxSmallRenderCommandSize)) {
 267         (void) __glXFlushRenderBuffer(gc, gc->pc);
 268     }
 269     if (cmdlen <= gc->maxSmallRenderCommandSize) {
 270         emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
 271         (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
 272         (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
 273         (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
 274         gc->pc += cmdlen;
 275         if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 276     }
 277     else {
 278         const GLint op = X_GLrop_CallLists;
 279         const GLuint cmdlenLarge = cmdlen + 4;
 280         (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
 281         (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
 282         (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
 283         (void) memcpy((void *)(gc->pc + 12), (void *)(&type), 4);
 284         __glXSendLargeCommand(gc, gc->pc, 16, lists, (compsize * n));
 285     }
 286 }
 287
 288 #define X_GLsop_DeleteLists 103
 289 void
 290 __indirect_glDeleteLists(GLuint list, GLsizei range)
 291 {
 292     __GLXcontext * const gc = __glXGetCurrentContext();
 293     Display * const dpy = gc->currentDpy;
 294     const GLuint cmdlen = 8;
 295     (void) dpy;
 296     if (dpy != NULL) {
 297         GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteLists, cmdlen);
 298         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 299         (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
 300         UnlockDisplay(gc->currentDpy); SyncHandle();
 301     }
 302     return;
 303 }
 304
 305 #define X_GLsop_GenLists 104
 306 GLuint
 307 __indirect_glGenLists(GLsizei range)
 308 {
 309     __GLXcontext * const gc = __glXGetCurrentContext();
 310     Display * const dpy = gc->currentDpy;
 311     GLuint retval = (GLuint) 0;
 312     const GLuint cmdlen = 4;
 313     (void) dpy;
 314     if (dpy != NULL) {
 315         GLubyte const * pc = setup_single_request(gc, X_GLsop_GenLists, cmdlen);
 316         (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
 317         retval = (GLuint) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
 318         UnlockDisplay(gc->currentDpy); SyncHandle();
 319     }
 320     return retval;
 321 }
 322
 323 #define X_GLrop_ListBase 3
 324 void
 325 __indirect_glListBase(GLuint base)
 326 {
 327     __GLXcontext * const gc = __glXGetCurrentContext();
 328     Display * const dpy = gc->currentDpy;
 329     const GLuint cmdlen = 8;
 330     (void) dpy;
 331     emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
 332     (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
 333     gc->pc += cmdlen;
 334     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 335 }
 336
 337 #define X_GLrop_Begin 4
 338 void
 339 __indirect_glBegin(GLenum mode)
 340 {
 341     __GLXcontext * const gc = __glXGetCurrentContext();
 342     Display * const dpy = gc->currentDpy;
 343     const GLuint cmdlen = 8;
 344     (void) dpy;
 345     emit_header(gc->pc, X_GLrop_Begin, cmdlen);
 346     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
 347     gc->pc += cmdlen;
 348     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 349 }
 350
 351 #define X_GLrop_Color3bv 6
 352 void
 353 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 354 {
 355     __GLXcontext * const gc = __glXGetCurrentContext();
 356     Display * const dpy = gc->currentDpy;
 357     const GLuint cmdlen = 8;
 358     (void) dpy;
 359     emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
 360     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 361     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 362     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 363     gc->pc += cmdlen;
 364     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 365 }
 366
 367 #define X_GLrop_Color3bv 6
 368 void
 369 __indirect_glColor3bv(const GLbyte * v)
 370 {
 371     generic_3_byte( X_GLrop_Color3bv, v );
 372 }
 373
 374 #define X_GLrop_Color3dv 7
 375 void
 376 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 377 {
 378     __GLXcontext * const gc = __glXGetCurrentContext();
 379     Display * const dpy = gc->currentDpy;
 380     const GLuint cmdlen = 28;
 381     (void) dpy;
 382     emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
 383     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 384     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 385     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 386     gc->pc += cmdlen;
 387     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 388 }
 389
 390 #define X_GLrop_Color3dv 7
 391 void
 392 __indirect_glColor3dv(const GLdouble * v)
 393 {
 394     generic_24_byte( X_GLrop_Color3dv, v );
 395 }
 396
 397 #define X_GLrop_Color3fv 8
 398 void
 399 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 400 {
 401     __GLXcontext * const gc = __glXGetCurrentContext();
 402     Display * const dpy = gc->currentDpy;
 403     const GLuint cmdlen = 16;
 404     (void) dpy;
 405     emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
 406     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 407     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 408     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 409     gc->pc += cmdlen;
 410     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 411 }
 412
 413 #define X_GLrop_Color3fv 8
 414 void
 415 __indirect_glColor3fv(const GLfloat * v)
 416 {
 417     generic_12_byte( X_GLrop_Color3fv, v );
 418 }
 419
 420 #define X_GLrop_Color3iv 9
 421 void
 422 __indirect_glColor3i(GLint red, GLint green, GLint blue)
 423 {
 424     __GLXcontext * const gc = __glXGetCurrentContext();
 425     Display * const dpy = gc->currentDpy;
 426     const GLuint cmdlen = 16;
 427     (void) dpy;
 428     emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
 429     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 430     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 431     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 432     gc->pc += cmdlen;
 433     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 434 }
 435
 436 #define X_GLrop_Color3iv 9
 437 void
 438 __indirect_glColor3iv(const GLint * v)
 439 {
 440     generic_12_byte( X_GLrop_Color3iv, v );
 441 }
 442
 443 #define X_GLrop_Color3sv 10
 444 void
 445 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
 446 {
 447     __GLXcontext * const gc = __glXGetCurrentContext();
 448     Display * const dpy = gc->currentDpy;
 449     const GLuint cmdlen = 12;
 450     (void) dpy;
 451     emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
 452     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 453     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 454     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 455     gc->pc += cmdlen;
 456     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 457 }
 458
 459 #define X_GLrop_Color3sv 10
 460 void
 461 __indirect_glColor3sv(const GLshort * v)
 462 {
 463     generic_6_byte( X_GLrop_Color3sv, v );
 464 }
 465
 466 #define X_GLrop_Color3ubv 11
 467 void
 468 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 469 {
 470     __GLXcontext * const gc = __glXGetCurrentContext();
 471     Display * const dpy = gc->currentDpy;
 472     const GLuint cmdlen = 8;
 473     (void) dpy;
 474     emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
 475     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 476     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 477     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 478     gc->pc += cmdlen;
 479     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 480 }
 481
 482 #define X_GLrop_Color3ubv 11
 483 void
 484 __indirect_glColor3ubv(const GLubyte * v)
 485 {
 486     generic_3_byte( X_GLrop_Color3ubv, v );
 487 }
 488
 489 #define X_GLrop_Color3uiv 12
 490 void
 491 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
 492 {
 493     __GLXcontext * const gc = __glXGetCurrentContext();
 494     Display * const dpy = gc->currentDpy;
 495     const GLuint cmdlen = 16;
 496     (void) dpy;
 497     emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
 498     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 499     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 500     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 501     gc->pc += cmdlen;
 502     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 503 }
 504
 505 #define X_GLrop_Color3uiv 12
 506 void
 507 __indirect_glColor3uiv(const GLuint * v)
 508 {
 509     generic_12_byte( X_GLrop_Color3uiv, v );
 510 }
 511
 512 #define X_GLrop_Color3usv 13
 513 void
 514 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
 515 {
 516     __GLXcontext * const gc = __glXGetCurrentContext();
 517     Display * const dpy = gc->currentDpy;
 518     const GLuint cmdlen = 12;
 519     (void) dpy;
 520     emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
 521     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 522     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 523     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 524     gc->pc += cmdlen;
 525     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 526 }
 527
 528 #define X_GLrop_Color3usv 13
 529 void
 530 __indirect_glColor3usv(const GLushort * v)
 531 {
 532     generic_6_byte( X_GLrop_Color3usv, v );
 533 }
 534
 535 #define X_GLrop_Color4bv 14
 536 void
 537 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 538 {
 539     __GLXcontext * const gc = __glXGetCurrentContext();
 540     Display * const dpy = gc->currentDpy;
 541     const GLuint cmdlen = 8;
 542     (void) dpy;
 543     emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
 544     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 545     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 546     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 547     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 548     gc->pc += cmdlen;
 549     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 550 }
 551
 552 #define X_GLrop_Color4bv 14
 553 void
 554 __indirect_glColor4bv(const GLbyte * v)
 555 {
 556     generic_4_byte( X_GLrop_Color4bv, v );
 557 }
 558
 559 #define X_GLrop_Color4dv 15
 560 void
 561 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 562 {
 563     __GLXcontext * const gc = __glXGetCurrentContext();
 564     Display * const dpy = gc->currentDpy;
 565     const GLuint cmdlen = 36;
 566     (void) dpy;
 567     emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
 568     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 569     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 570     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 571     (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
 572     gc->pc += cmdlen;
 573     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 574 }
 575
 576 #define X_GLrop_Color4dv 15
 577 void
 578 __indirect_glColor4dv(const GLdouble * v)
 579 {
 580     generic_32_byte( X_GLrop_Color4dv, v );
 581 }
 582
 583 #define X_GLrop_Color4fv 16
 584 void
 585 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 586 {
 587     __GLXcontext * const gc = __glXGetCurrentContext();
 588     Display * const dpy = gc->currentDpy;
 589     const GLuint cmdlen = 20;
 590     (void) dpy;
 591     emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
 592     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 593     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 594     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 595     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 596     gc->pc += cmdlen;
 597     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 598 }
 599
 600 #define X_GLrop_Color4fv 16
 601 void
 602 __indirect_glColor4fv(const GLfloat * v)
 603 {
 604     generic_16_byte( X_GLrop_Color4fv, v );
 605 }
 606
 607 #define X_GLrop_Color4iv 17
 608 void
 609 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 610 {
 611     __GLXcontext * const gc = __glXGetCurrentContext();
 612     Display * const dpy = gc->currentDpy;
 613     const GLuint cmdlen = 20;
 614     (void) dpy;
 615     emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
 616     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 617     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 618     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 619     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 620     gc->pc += cmdlen;
 621     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 622 }
 623
 624 #define X_GLrop_Color4iv 17
 625 void
 626 __indirect_glColor4iv(const GLint * v)
 627 {
 628     generic_16_byte( X_GLrop_Color4iv, v );
 629 }
 630
 631 #define X_GLrop_Color4sv 18
 632 void
 633 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 634 {
 635     __GLXcontext * const gc = __glXGetCurrentContext();
 636     Display * const dpy = gc->currentDpy;
 637     const GLuint cmdlen = 12;
 638     (void) dpy;
 639     emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
 640     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 641     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 642     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 643     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 644     gc->pc += cmdlen;
 645     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 646 }
 647
 648 #define X_GLrop_Color4sv 18
 649 void
 650 __indirect_glColor4sv(const GLshort * v)
 651 {
 652     generic_8_byte( X_GLrop_Color4sv, v );
 653 }
 654
 655 #define X_GLrop_Color4ubv 19
 656 void
 657 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 658 {
 659     __GLXcontext * const gc = __glXGetCurrentContext();
 660     Display * const dpy = gc->currentDpy;
 661     const GLuint cmdlen = 8;
 662     (void) dpy;
 663     emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
 664     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 665     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 666     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 667     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 668     gc->pc += cmdlen;
 669     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 670 }
 671
 672 #define X_GLrop_Color4ubv 19
 673 void
 674 __indirect_glColor4ubv(const GLubyte * v)
 675 {
 676     generic_4_byte( X_GLrop_Color4ubv, v );
 677 }
 678
 679 #define X_GLrop_Color4uiv 20
 680 void
 681 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 682 {
 683     __GLXcontext * const gc = __glXGetCurrentContext();
 684     Display * const dpy = gc->currentDpy;
 685     const GLuint cmdlen = 20;
 686     (void) dpy;
 687     emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
 688     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 689     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 690     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 691     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 692     gc->pc += cmdlen;
 693     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 694 }
 695
 696 #define X_GLrop_Color4uiv 20
 697 void
 698 __indirect_glColor4uiv(const GLuint * v)
 699 {
 700     generic_16_byte( X_GLrop_Color4uiv, v );
 701 }
 702
 703 #define X_GLrop_Color4usv 21
 704 void
 705 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 706 {
 707     __GLXcontext * const gc = __glXGetCurrentContext();
 708     Display * const dpy = gc->currentDpy;
 709     const GLuint cmdlen = 12;
 710     (void) dpy;
 711     emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
 712     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 713     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 714     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 715     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 716     gc->pc += cmdlen;
 717     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 718 }
 719
 720 #define X_GLrop_Color4usv 21
 721 void
 722 __indirect_glColor4usv(const GLushort * v)
 723 {
 724     generic_8_byte( X_GLrop_Color4usv, v );
 725 }
 726
 727 #define X_GLrop_EdgeFlagv 22
 728 void
 729 __indirect_glEdgeFlag(GLboolean flag)
 730 {
 731     __GLXcontext * const gc = __glXGetCurrentContext();
 732     Display * const dpy = gc->currentDpy;
 733     const GLuint cmdlen = 8;
 734     (void) dpy;
 735     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 736     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
 737     gc->pc += cmdlen;
 738     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 739 }
 740
 741 #define X_GLrop_EdgeFlagv 22
 742 void
 743 __indirect_glEdgeFlagv(const GLboolean * flag)
 744 {
 745     __GLXcontext * const gc = __glXGetCurrentContext();
 746     Display * const dpy = gc->currentDpy;
 747     const GLuint cmdlen = 8;
 748     (void) dpy;
 749     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 750     (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
 751     gc->pc += cmdlen;
 752     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 753 }
 754
 755 #define X_GLrop_End 23
 756 void
 757 __indirect_glEnd(void)
 758 {
 759     __GLXcontext * const gc = __glXGetCurrentContext();
 760     Display * const dpy = gc->currentDpy;
 761     const GLuint cmdlen = 4;
 762     (void) dpy;
 763     emit_header(gc->pc, X_GLrop_End, cmdlen);
 764     gc->pc += cmdlen;
 765     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 766 }
 767
 768 #define X_GLrop_Indexdv 24
 769 void
 770 __indirect_glIndexd(GLdouble c)
 771 {
 772     __GLXcontext * const gc = __glXGetCurrentContext();
 773     Display * const dpy = gc->currentDpy;
 774     const GLuint cmdlen = 12;
 775     (void) dpy;
 776     emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
 777     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
 778     gc->pc += cmdlen;
 779     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 780 }
 781
 782 #define X_GLrop_Indexdv 24
 783 void
 784 __indirect_glIndexdv(const GLdouble * c)
 785 {
 786     generic_8_byte( X_GLrop_Indexdv, c );
 787 }
 788
 789 #define X_GLrop_Indexfv 25
 790 void
 791 __indirect_glIndexf(GLfloat c)
 792 {
 793     __GLXcontext * const gc = __glXGetCurrentContext();
 794     Display * const dpy = gc->currentDpy;
 795     const GLuint cmdlen = 8;
 796     (void) dpy;
 797     emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
 798     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 799     gc->pc += cmdlen;
 800     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 801 }
 802
 803 #define X_GLrop_Indexfv 25
 804 void
 805 __indirect_glIndexfv(const GLfloat * c)
 806 {
 807     generic_4_byte( X_GLrop_Indexfv, c );
 808 }
 809
 810 #define X_GLrop_Indexiv 26
 811 void
 812 __indirect_glIndexi(GLint c)
 813 {
 814     __GLXcontext * const gc = __glXGetCurrentContext();
 815     Display * const dpy = gc->currentDpy;
 816     const GLuint cmdlen = 8;
 817     (void) dpy;
 818     emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
 819     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 820     gc->pc += cmdlen;
 821     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 822 }
 823
 824 #define X_GLrop_Indexiv 26
 825 void
 826 __indirect_glIndexiv(const GLint * c)
 827 {
 828     generic_4_byte( X_GLrop_Indexiv, c );
 829 }
 830
 831 #define X_GLrop_Indexsv 27
 832 void
 833 __indirect_glIndexs(GLshort c)
 834 {
 835     __GLXcontext * const gc = __glXGetCurrentContext();
 836     Display * const dpy = gc->currentDpy;
 837     const GLuint cmdlen = 8;
 838     (void) dpy;
 839     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 840     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
 841     gc->pc += cmdlen;
 842     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 843 }
 844
 845 #define X_GLrop_Indexsv 27
 846 void
 847 __indirect_glIndexsv(const GLshort * c)
 848 {
 849     __GLXcontext * const gc = __glXGetCurrentContext();
 850     Display * const dpy = gc->currentDpy;
 851     const GLuint cmdlen = 8;
 852     (void) dpy;
 853     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 854     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
 855     gc->pc += cmdlen;
 856     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 857 }
 858
 859 #define X_GLrop_Normal3bv 28
 860 void
 861 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 862 {
 863     __GLXcontext * const gc = __glXGetCurrentContext();
 864     Display * const dpy = gc->currentDpy;
 865     const GLuint cmdlen = 8;
 866     (void) dpy;
 867     emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
 868     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
 869     (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
 870     (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
 871     gc->pc += cmdlen;
 872     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 873 }
 874
 875 #define X_GLrop_Normal3bv 28
 876 void
 877 __indirect_glNormal3bv(const GLbyte * v)
 878 {
 879     generic_3_byte( X_GLrop_Normal3bv, v );
 880 }
 881
 882 #define X_GLrop_Normal3dv 29
 883 void
 884 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 885 {
 886     __GLXcontext * const gc = __glXGetCurrentContext();
 887     Display * const dpy = gc->currentDpy;
 888     const GLuint cmdlen = 28;
 889     (void) dpy;
 890     emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
 891     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
 892     (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
 893     (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
 894     gc->pc += cmdlen;
 895     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 896 }
 897
 898 #define X_GLrop_Normal3dv 29
 899 void
 900 __indirect_glNormal3dv(const GLdouble * v)
 901 {
 902     generic_24_byte( X_GLrop_Normal3dv, v );
 903 }
 904
 905 #define X_GLrop_Normal3fv 30
 906 void
 907 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 908 {
 909     __GLXcontext * const gc = __glXGetCurrentContext();
 910     Display * const dpy = gc->currentDpy;
 911     const GLuint cmdlen = 16;
 912     (void) dpy;
 913     emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
 914     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 915     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 916     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 917     gc->pc += cmdlen;
 918     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 919 }
 920
 921 #define X_GLrop_Normal3fv 30
 922 void
 923 __indirect_glNormal3fv(const GLfloat * v)
 924 {
 925     generic_12_byte( X_GLrop_Normal3fv, v );
 926 }
 927
 928 #define X_GLrop_Normal3iv 31
 929 void
 930 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
 931 {
 932     __GLXcontext * const gc = __glXGetCurrentContext();
 933     Display * const dpy = gc->currentDpy;
 934     const GLuint cmdlen = 16;
 935     (void) dpy;
 936     emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
 937     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 938     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 939     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 940     gc->pc += cmdlen;
 941     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 942 }
 943
 944 #define X_GLrop_Normal3iv 31
 945 void
 946 __indirect_glNormal3iv(const GLint * v)
 947 {
 948     generic_12_byte( X_GLrop_Normal3iv, v );
 949 }
 950
 951 #define X_GLrop_Normal3sv 32
 952 void
 953 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 954 {
 955     __GLXcontext * const gc = __glXGetCurrentContext();
 956     Display * const dpy = gc->currentDpy;
 957     const GLuint cmdlen = 12;
 958     (void) dpy;
 959     emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
 960     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
 961     (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
 962     (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
 963     gc->pc += cmdlen;
 964     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 965 }
 966
 967 #define X_GLrop_Normal3sv 32
 968 void
 969 __indirect_glNormal3sv(const GLshort * v)
 970 {
 971     generic_6_byte( X_GLrop_Normal3sv, v );
 972 }
 973
 974 #define X_GLrop_RasterPos2dv 33
 975 void
 976 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
 977 {
 978     __GLXcontext * const gc = __glXGetCurrentContext();
 979     Display * const dpy = gc->currentDpy;
 980     const GLuint cmdlen = 20;
 981     (void) dpy;
 982     emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
 983     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
 984     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
 985     gc->pc += cmdlen;
 986     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 987 }
 988
 989 #define X_GLrop_RasterPos2dv 33
 990 void
 991 __indirect_glRasterPos2dv(const GLdouble * v)
 992 {
 993     generic_16_byte( X_GLrop_RasterPos2dv, v );
 994 }
 995
 996 #define X_GLrop_RasterPos2fv 34
 997 void
 998 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
 999 {
1000     __GLXcontext * const gc = __glXGetCurrentContext();
1001     Display * const dpy = gc->currentDpy;
1002     const GLuint cmdlen = 12;
1003     (void) dpy;
1004     emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1005     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1006     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1007     gc->pc += cmdlen;
1008     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1009 }
1010
1011 #define X_GLrop_RasterPos2fv 34
1012 void
1013 __indirect_glRasterPos2fv(const GLfloat * v)
1014 {
1015     generic_8_byte( X_GLrop_RasterPos2fv, v );
1016 }
1017
1018 #define X_GLrop_RasterPos2iv 35
1019 void
1020 __indirect_glRasterPos2i(GLint x, GLint y)
1021 {
1022     __GLXcontext * const gc = __glXGetCurrentContext();
1023     Display * const dpy = gc->currentDpy;
1024     const GLuint cmdlen = 12;
1025     (void) dpy;
1026     emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1027     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1028     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1029     gc->pc += cmdlen;
1030     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1031 }
1032
1033 #define X_GLrop_RasterPos2iv 35
1034 void
1035 __indirect_glRasterPos2iv(const GLint * v)
1036 {
1037     generic_8_byte( X_GLrop_RasterPos2iv, v );
1038 }
1039
1040 #define X_GLrop_RasterPos2sv 36
1041 void
1042 __indirect_glRasterPos2s(GLshort x, GLshort y)
1043 {
1044     __GLXcontext * const gc = __glXGetCurrentContext();
1045     Display * const dpy = gc->currentDpy;
1046     const GLuint cmdlen = 8;
1047     (void) dpy;
1048     emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1049     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1050     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1051     gc->pc += cmdlen;
1052     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1053 }
1054
1055 #define X_GLrop_RasterPos2sv 36
1056 void
1057 __indirect_glRasterPos2sv(const GLshort * v)
1058 {
1059     generic_4_byte( X_GLrop_RasterPos2sv, v );
1060 }
1061
1062 #define X_GLrop_RasterPos3dv 37
1063 void
1064 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1065 {
1066     __GLXcontext * const gc = __glXGetCurrentContext();
1067     Display * const dpy = gc->currentDpy;
1068     const GLuint cmdlen = 28;
1069     (void) dpy;
1070     emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1071     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1072     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1073     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1074     gc->pc += cmdlen;
1075     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1076 }
1077
1078 #define X_GLrop_RasterPos3dv 37
1079 void
1080 __indirect_glRasterPos3dv(const GLdouble * v)
1081 {
1082     generic_24_byte( X_GLrop_RasterPos3dv, v );
1083 }
1084
1085 #define X_GLrop_RasterPos3fv 38
1086 void
1087 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1088 {
1089     __GLXcontext * const gc = __glXGetCurrentContext();
1090     Display * const dpy = gc->currentDpy;
1091     const GLuint cmdlen = 16;
1092     (void) dpy;
1093     emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1094     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1095     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1096     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1097     gc->pc += cmdlen;
1098     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1099 }
1100
1101 #define X_GLrop_RasterPos3fv 38
1102 void
1103 __indirect_glRasterPos3fv(const GLfloat * v)
1104 {
1105     generic_12_byte( X_GLrop_RasterPos3fv, v );
1106 }
1107
1108 #define X_GLrop_RasterPos3iv 39
1109 void
1110 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1111 {
1112     __GLXcontext * const gc = __glXGetCurrentContext();
1113     Display * const dpy = gc->currentDpy;
1114     const GLuint cmdlen = 16;
1115     (void) dpy;
1116     emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1117     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1118     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1119     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1120     gc->pc += cmdlen;
1121     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1122 }
1123
1124 #define X_GLrop_RasterPos3iv 39
1125 void
1126 __indirect_glRasterPos3iv(const GLint * v)
1127 {
1128     generic_12_byte( X_GLrop_RasterPos3iv, v );
1129 }
1130
1131 #define X_GLrop_RasterPos3sv 40
1132 void
1133 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1134 {
1135     __GLXcontext * const gc = __glXGetCurrentContext();
1136     Display * const dpy = gc->currentDpy;
1137     const GLuint cmdlen = 12;
1138     (void) dpy;
1139     emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1140     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1141     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1142     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1143     gc->pc += cmdlen;
1144     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1145 }
1146
1147 #define X_GLrop_RasterPos3sv 40
1148 void
1149 __indirect_glRasterPos3sv(const GLshort * v)
1150 {
1151     generic_6_byte( X_GLrop_RasterPos3sv, v );
1152 }
1153
1154 #define X_GLrop_RasterPos4dv 41
1155 void
1156 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1157 {
1158     __GLXcontext * const gc = __glXGetCurrentContext();
1159     Display * const dpy = gc->currentDpy;
1160     const GLuint cmdlen = 36;
1161     (void) dpy;
1162     emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1163     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1164     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1165     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1166     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1167     gc->pc += cmdlen;
1168     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1169 }
1170
1171 #define X_GLrop_RasterPos4dv 41
1172 void
1173 __indirect_glRasterPos4dv(const GLdouble * v)
1174 {
1175     generic_32_byte( X_GLrop_RasterPos4dv, v );
1176 }
1177
1178 #define X_GLrop_RasterPos4fv 42
1179 void
1180 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1181 {
1182     __GLXcontext * const gc = __glXGetCurrentContext();
1183     Display * const dpy = gc->currentDpy;
1184     const GLuint cmdlen = 20;
1185     (void) dpy;
1186     emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1187     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1188     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1189     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1190     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1191     gc->pc += cmdlen;
1192     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1193 }
1194
1195 #define X_GLrop_RasterPos4fv 42
1196 void
1197 __indirect_glRasterPos4fv(const GLfloat * v)
1198 {
1199     generic_16_byte( X_GLrop_RasterPos4fv, v );
1200 }
1201
1202 #define X_GLrop_RasterPos4iv 43
1203 void
1204 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1205 {
1206     __GLXcontext * const gc = __glXGetCurrentContext();
1207     Display * const dpy = gc->currentDpy;
1208     const GLuint cmdlen = 20;
1209     (void) dpy;
1210     emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1211     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1212     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1213     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1214     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1215     gc->pc += cmdlen;
1216     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1217 }
1218
1219 #define X_GLrop_RasterPos4iv 43
1220 void
1221 __indirect_glRasterPos4iv(const GLint * v)
1222 {
1223     generic_16_byte( X_GLrop_RasterPos4iv, v );
1224 }
1225
1226 #define X_GLrop_RasterPos4sv 44
1227 void
1228 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1229 {
1230     __GLXcontext * const gc = __glXGetCurrentContext();
1231     Display * const dpy = gc->currentDpy;
1232     const GLuint cmdlen = 12;
1233     (void) dpy;
1234     emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1235     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1236     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1237     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1238     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1239     gc->pc += cmdlen;
1240     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1241 }
1242
1243 #define X_GLrop_RasterPos4sv 44
1244 void
1245 __indirect_glRasterPos4sv(const GLshort * v)
1246 {
1247     generic_8_byte( X_GLrop_RasterPos4sv, v );
1248 }
1249
1250 #define X_GLrop_Rectdv 45
1251 void
1252 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1253 {
1254     __GLXcontext * const gc = __glXGetCurrentContext();
1255     Display * const dpy = gc->currentDpy;
1256     const GLuint cmdlen = 36;
1257     (void) dpy;
1258     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1259     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
1260     (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
1261     (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
1262     (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
1263     gc->pc += cmdlen;
1264     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1265 }
1266
1267 #define X_GLrop_Rectdv 45
1268 void
1269 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1270 {
1271     __GLXcontext * const gc = __glXGetCurrentContext();
1272     Display * const dpy = gc->currentDpy;
1273     const GLuint cmdlen = 36;
1274     (void) dpy;
1275     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1276     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
1277     (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
1278     gc->pc += cmdlen;
1279     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1280 }
1281
1282 #define X_GLrop_Rectfv 46
1283 void
1284 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1285 {
1286     __GLXcontext * const gc = __glXGetCurrentContext();
1287     Display * const dpy = gc->currentDpy;
1288     const GLuint cmdlen = 20;
1289     (void) dpy;
1290     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1291     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1292     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1293     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1294     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1295     gc->pc += cmdlen;
1296     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1297 }
1298
1299 #define X_GLrop_Rectfv 46
1300 void
1301 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1302 {
1303     __GLXcontext * const gc = __glXGetCurrentContext();
1304     Display * const dpy = gc->currentDpy;
1305     const GLuint cmdlen = 20;
1306     (void) dpy;
1307     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1308     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1309     (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1310     gc->pc += cmdlen;
1311     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1312 }
1313
1314 #define X_GLrop_Rectiv 47
1315 void
1316 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1317 {
1318     __GLXcontext * const gc = __glXGetCurrentContext();
1319     Display * const dpy = gc->currentDpy;
1320     const GLuint cmdlen = 20;
1321     (void) dpy;
1322     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1323     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1324     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1325     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1326     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1327     gc->pc += cmdlen;
1328     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1329 }
1330
1331 #define X_GLrop_Rectiv 47
1332 void
1333 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1334 {
1335     __GLXcontext * const gc = __glXGetCurrentContext();
1336     Display * const dpy = gc->currentDpy;
1337     const GLuint cmdlen = 20;
1338     (void) dpy;
1339     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1340     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1341     (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1342     gc->pc += cmdlen;
1343     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1344 }
1345
1346 #define X_GLrop_Rectsv 48
1347 void
1348 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1349 {
1350     __GLXcontext * const gc = __glXGetCurrentContext();
1351     Display * const dpy = gc->currentDpy;
1352     const GLuint cmdlen = 12;
1353     (void) dpy;
1354     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1355     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
1356     (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
1357     (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
1358     (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
1359     gc->pc += cmdlen;
1360     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1361 }
1362
1363 #define X_GLrop_Rectsv 48
1364 void
1365 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1366 {
1367     __GLXcontext * const gc = __glXGetCurrentContext();
1368     Display * const dpy = gc->currentDpy;
1369     const GLuint cmdlen = 12;
1370     (void) dpy;
1371     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1372     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
1373     (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
1374     gc->pc += cmdlen;
1375     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1376 }
1377
1378 #define X_GLrop_TexCoord1dv 49
1379 void
1380 __indirect_glTexCoord1d(GLdouble s)
1381 {
1382     __GLXcontext * const gc = __glXGetCurrentContext();
1383     Display * const dpy = gc->currentDpy;
1384     const GLuint cmdlen = 12;
1385     (void) dpy;
1386     emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1387     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1388     gc->pc += cmdlen;
1389     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1390 }
1391
1392 #define X_GLrop_TexCoord1dv 49
1393 void
1394 __indirect_glTexCoord1dv(const GLdouble * v)
1395 {
1396     generic_8_byte( X_GLrop_TexCoord1dv, v );
1397 }
1398
1399 #define X_GLrop_TexCoord1fv 50
1400 void
1401 __indirect_glTexCoord1f(GLfloat s)
1402 {
1403     __GLXcontext * const gc = __glXGetCurrentContext();
1404     Display * const dpy = gc->currentDpy;
1405     const GLuint cmdlen = 8;
1406     (void) dpy;
1407     emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1408     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1409     gc->pc += cmdlen;
1410     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1411 }
1412
1413 #define X_GLrop_TexCoord1fv 50
1414 void
1415 __indirect_glTexCoord1fv(const GLfloat * v)
1416 {
1417     generic_4_byte( X_GLrop_TexCoord1fv, v );
1418 }
1419
1420 #define X_GLrop_TexCoord1iv 51
1421 void
1422 __indirect_glTexCoord1i(GLint s)
1423 {
1424     __GLXcontext * const gc = __glXGetCurrentContext();
1425     Display * const dpy = gc->currentDpy;
1426     const GLuint cmdlen = 8;
1427     (void) dpy;
1428     emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1429     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1430     gc->pc += cmdlen;
1431     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1432 }
1433
1434 #define X_GLrop_TexCoord1iv 51
1435 void
1436 __indirect_glTexCoord1iv(const GLint * v)
1437 {
1438     generic_4_byte( X_GLrop_TexCoord1iv, v );
1439 }
1440
1441 #define X_GLrop_TexCoord1sv 52
1442 void
1443 __indirect_glTexCoord1s(GLshort s)
1444 {
1445     __GLXcontext * const gc = __glXGetCurrentContext();
1446     Display * const dpy = gc->currentDpy;
1447     const GLuint cmdlen = 8;
1448     (void) dpy;
1449     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1450     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1451     gc->pc += cmdlen;
1452     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1453 }
1454
1455 #define X_GLrop_TexCoord1sv 52
1456 void
1457 __indirect_glTexCoord1sv(const GLshort * v)
1458 {
1459     __GLXcontext * const gc = __glXGetCurrentContext();
1460     Display * const dpy = gc->currentDpy;
1461     const GLuint cmdlen = 8;
1462     (void) dpy;
1463     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1464     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
1465     gc->pc += cmdlen;
1466     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1467 }
1468
1469 #define X_GLrop_TexCoord2dv 53
1470 void
1471 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1472 {
1473     __GLXcontext * const gc = __glXGetCurrentContext();
1474     Display * const dpy = gc->currentDpy;
1475     const GLuint cmdlen = 20;
1476     (void) dpy;
1477     emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1478     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1479     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1480     gc->pc += cmdlen;
1481     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1482 }
1483
1484 #define X_GLrop_TexCoord2dv 53
1485 void
1486 __indirect_glTexCoord2dv(const GLdouble * v)
1487 {
1488     generic_16_byte( X_GLrop_TexCoord2dv, v );
1489 }
1490
1491 #define X_GLrop_TexCoord2fv 54
1492 void
1493 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1494 {
1495     __GLXcontext * const gc = __glXGetCurrentContext();
1496     Display * const dpy = gc->currentDpy;
1497     const GLuint cmdlen = 12;
1498     (void) dpy;
1499     emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1500     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1501     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1502     gc->pc += cmdlen;
1503     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1504 }
1505
1506 #define X_GLrop_TexCoord2fv 54
1507 void
1508 __indirect_glTexCoord2fv(const GLfloat * v)
1509 {
1510     generic_8_byte( X_GLrop_TexCoord2fv, v );
1511 }
1512
1513 #define X_GLrop_TexCoord2iv 55
1514 void
1515 __indirect_glTexCoord2i(GLint s, GLint t)
1516 {
1517     __GLXcontext * const gc = __glXGetCurrentContext();
1518     Display * const dpy = gc->currentDpy;
1519     const GLuint cmdlen = 12;
1520     (void) dpy;
1521     emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1522     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1523     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1524     gc->pc += cmdlen;
1525     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1526 }
1527
1528 #define X_GLrop_TexCoord2iv 55
1529 void
1530 __indirect_glTexCoord2iv(const GLint * v)
1531 {
1532     generic_8_byte( X_GLrop_TexCoord2iv, v );
1533 }
1534
1535 #define X_GLrop_TexCoord2sv 56
1536 void
1537 __indirect_glTexCoord2s(GLshort s, GLshort t)
1538 {
1539     __GLXcontext * const gc = __glXGetCurrentContext();
1540     Display * const dpy = gc->currentDpy;
1541     const GLuint cmdlen = 8;
1542     (void) dpy;
1543     emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1544     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1545     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1546     gc->pc += cmdlen;
1547     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1548 }
1549
1550 #define X_GLrop_TexCoord2sv 56
1551 void
1552 __indirect_glTexCoord2sv(const GLshort * v)
1553 {
1554     generic_4_byte( X_GLrop_TexCoord2sv, v );
1555 }
1556
1557 #define X_GLrop_TexCoord3dv 57
1558 void
1559 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1560 {
1561     __GLXcontext * const gc = __glXGetCurrentContext();
1562     Display * const dpy = gc->currentDpy;
1563     const GLuint cmdlen = 28;
1564     (void) dpy;
1565     emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1566     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1567     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1568     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1569     gc->pc += cmdlen;
1570     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1571 }
1572
1573 #define X_GLrop_TexCoord3dv 57
1574 void
1575 __indirect_glTexCoord3dv(const GLdouble * v)
1576 {
1577     generic_24_byte( X_GLrop_TexCoord3dv, v );
1578 }
1579
1580 #define X_GLrop_TexCoord3fv 58
1581 void
1582 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1583 {
1584     __GLXcontext * const gc = __glXGetCurrentContext();
1585     Display * const dpy = gc->currentDpy;
1586     const GLuint cmdlen = 16;
1587     (void) dpy;
1588     emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1589     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1590     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1591     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1592     gc->pc += cmdlen;
1593     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1594 }
1595
1596 #define X_GLrop_TexCoord3fv 58
1597 void
1598 __indirect_glTexCoord3fv(const GLfloat * v)
1599 {
1600     generic_12_byte( X_GLrop_TexCoord3fv, v );
1601 }
1602
1603 #define X_GLrop_TexCoord3iv 59
1604 void
1605 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1606 {
1607     __GLXcontext * const gc = __glXGetCurrentContext();
1608     Display * const dpy = gc->currentDpy;
1609     const GLuint cmdlen = 16;
1610     (void) dpy;
1611     emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1612     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1613     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1614     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1615     gc->pc += cmdlen;
1616     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1617 }
1618
1619 #define X_GLrop_TexCoord3iv 59
1620 void
1621 __indirect_glTexCoord3iv(const GLint * v)
1622 {
1623     generic_12_byte( X_GLrop_TexCoord3iv, v );
1624 }
1625
1626 #define X_GLrop_TexCoord3sv 60
1627 void
1628 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1629 {
1630     __GLXcontext * const gc = __glXGetCurrentContext();
1631     Display * const dpy = gc->currentDpy;
1632     const GLuint cmdlen = 12;
1633     (void) dpy;
1634     emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1635     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1636     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1637     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1638     gc->pc += cmdlen;
1639     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1640 }
1641
1642 #define X_GLrop_TexCoord3sv 60
1643 void
1644 __indirect_glTexCoord3sv(const GLshort * v)
1645 {
1646     generic_6_byte( X_GLrop_TexCoord3sv, v );
1647 }
1648
1649 #define X_GLrop_TexCoord4dv 61
1650 void
1651 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1652 {
1653     __GLXcontext * const gc = __glXGetCurrentContext();
1654     Display * const dpy = gc->currentDpy;
1655     const GLuint cmdlen = 36;
1656     (void) dpy;
1657     emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1658     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1659     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1660     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1661     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
1662     gc->pc += cmdlen;
1663     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1664 }
1665
1666 #define X_GLrop_TexCoord4dv 61
1667 void
1668 __indirect_glTexCoord4dv(const GLdouble * v)
1669 {
1670     generic_32_byte( X_GLrop_TexCoord4dv, v );
1671 }
1672
1673 #define X_GLrop_TexCoord4fv 62
1674 void
1675 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1676 {
1677     __GLXcontext * const gc = __glXGetCurrentContext();
1678     Display * const dpy = gc->currentDpy;
1679     const GLuint cmdlen = 20;
1680     (void) dpy;
1681     emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1682     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1683     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1684     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1685     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1686     gc->pc += cmdlen;
1687     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1688 }
1689
1690 #define X_GLrop_TexCoord4fv 62
1691 void
1692 __indirect_glTexCoord4fv(const GLfloat * v)
1693 {
1694     generic_16_byte( X_GLrop_TexCoord4fv, v );
1695 }
1696
1697 #define X_GLrop_TexCoord4iv 63
1698 void
1699 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1700 {
1701     __GLXcontext * const gc = __glXGetCurrentContext();
1702     Display * const dpy = gc->currentDpy;
1703     const GLuint cmdlen = 20;
1704     (void) dpy;
1705     emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1706     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1707     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1708     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1709     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1710     gc->pc += cmdlen;
1711     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1712 }
1713
1714 #define X_GLrop_TexCoord4iv 63
1715 void
1716 __indirect_glTexCoord4iv(const GLint * v)
1717 {
1718     generic_16_byte( X_GLrop_TexCoord4iv, v );
1719 }
1720
1721 #define X_GLrop_TexCoord4sv 64
1722 void
1723 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1724 {
1725     __GLXcontext * const gc = __glXGetCurrentContext();
1726     Display * const dpy = gc->currentDpy;
1727     const GLuint cmdlen = 12;
1728     (void) dpy;
1729     emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1730     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1731     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1732     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1733     (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
1734     gc->pc += cmdlen;
1735     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1736 }
1737
1738 #define X_GLrop_TexCoord4sv 64
1739 void
1740 __indirect_glTexCoord4sv(const GLshort * v)
1741 {
1742     generic_8_byte( X_GLrop_TexCoord4sv, v );
1743 }
1744
1745 #define X_GLrop_Vertex2dv 65
1746 void
1747 __indirect_glVertex2d(GLdouble x, GLdouble y)
1748 {
1749     __GLXcontext * const gc = __glXGetCurrentContext();
1750     Display * const dpy = gc->currentDpy;
1751     const GLuint cmdlen = 20;
1752     (void) dpy;
1753     emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1754     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1755     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1756     gc->pc += cmdlen;
1757     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1758 }
1759
1760 #define X_GLrop_Vertex2dv 65
1761 void
1762 __indirect_glVertex2dv(const GLdouble * v)
1763 {
1764     generic_16_byte( X_GLrop_Vertex2dv, v );
1765 }
1766
1767 #define X_GLrop_Vertex2fv 66
1768 void
1769 __indirect_glVertex2f(GLfloat x, GLfloat y)
1770 {
1771     __GLXcontext * const gc = __glXGetCurrentContext();
1772     Display * const dpy = gc->currentDpy;
1773     const GLuint cmdlen = 12;
1774     (void) dpy;
1775     emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1776     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1777     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1778     gc->pc += cmdlen;
1779     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1780 }
1781
1782 #define X_GLrop_Vertex2fv 66
1783 void
1784 __indirect_glVertex2fv(const GLfloat * v)
1785 {
1786     generic_8_byte( X_GLrop_Vertex2fv, v );
1787 }
1788
1789 #define X_GLrop_Vertex2iv 67
1790 void
1791 __indirect_glVertex2i(GLint x, GLint y)
1792 {
1793     __GLXcontext * const gc = __glXGetCurrentContext();
1794     Display * const dpy = gc->currentDpy;
1795     const GLuint cmdlen = 12;
1796     (void) dpy;
1797     emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1798     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1799     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1800     gc->pc += cmdlen;
1801     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1802 }
1803
1804 #define X_GLrop_Vertex2iv 67
1805 void
1806 __indirect_glVertex2iv(const GLint * v)
1807 {
1808     generic_8_byte( X_GLrop_Vertex2iv, v );
1809 }
1810
1811 #define X_GLrop_Vertex2sv 68
1812 void
1813 __indirect_glVertex2s(GLshort x, GLshort y)
1814 {
1815     __GLXcontext * const gc = __glXGetCurrentContext();
1816     Display * const dpy = gc->currentDpy;
1817     const GLuint cmdlen = 8;
1818     (void) dpy;
1819     emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
1820     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1821     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1822     gc->pc += cmdlen;
1823     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1824 }
1825
1826 #define X_GLrop_Vertex2sv 68
1827 void
1828 __indirect_glVertex2sv(const GLshort * v)
1829 {
1830     generic_4_byte( X_GLrop_Vertex2sv, v );
1831 }
1832
1833 #define X_GLrop_Vertex3dv 69
1834 void
1835 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
1836 {
1837     __GLXcontext * const gc = __glXGetCurrentContext();
1838     Display * const dpy = gc->currentDpy;
1839     const GLuint cmdlen = 28;
1840     (void) dpy;
1841     emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
1842     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1843     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1844     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1845     gc->pc += cmdlen;
1846     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1847 }
1848
1849 #define X_GLrop_Vertex3dv 69
1850 void
1851 __indirect_glVertex3dv(const GLdouble * v)
1852 {
1853     generic_24_byte( X_GLrop_Vertex3dv, v );
1854 }
1855
1856 #define X_GLrop_Vertex3fv 70
1857 void
1858 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
1859 {
1860     __GLXcontext * const gc = __glXGetCurrentContext();
1861     Display * const dpy = gc->currentDpy;
1862     const GLuint cmdlen = 16;
1863     (void) dpy;
1864     emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
1865     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1866     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1867     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1868     gc->pc += cmdlen;
1869     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1870 }
1871
1872 #define X_GLrop_Vertex3fv 70
1873 void
1874 __indirect_glVertex3fv(const GLfloat * v)
1875 {
1876     generic_12_byte( X_GLrop_Vertex3fv, v );
1877 }
1878
1879 #define X_GLrop_Vertex3iv 71
1880 void
1881 __indirect_glVertex3i(GLint x, GLint y, GLint z)
1882 {
1883     __GLXcontext * const gc = __glXGetCurrentContext();
1884     Display * const dpy = gc->currentDpy;
1885     const GLuint cmdlen = 16;
1886     (void) dpy;
1887     emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
1888     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1889     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1890     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1891     gc->pc += cmdlen;
1892     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1893 }
1894
1895 #define X_GLrop_Vertex3iv 71
1896 void
1897 __indirect_glVertex3iv(const GLint * v)
1898 {
1899     generic_12_byte( X_GLrop_Vertex3iv, v );
1900 }
1901
1902 #define X_GLrop_Vertex3sv 72
1903 void
1904 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
1905 {
1906     __GLXcontext * const gc = __glXGetCurrentContext();
1907     Display * const dpy = gc->currentDpy;
1908     const GLuint cmdlen = 12;
1909     (void) dpy;
1910     emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
1911     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1912     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1913     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1914     gc->pc += cmdlen;
1915     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1916 }
1917
1918 #define X_GLrop_Vertex3sv 72
1919 void
1920 __indirect_glVertex3sv(const GLshort * v)
1921 {
1922     generic_6_byte( X_GLrop_Vertex3sv, v );
1923 }
1924
1925 #define X_GLrop_Vertex4dv 73
1926 void
1927 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1928 {
1929     __GLXcontext * const gc = __glXGetCurrentContext();
1930     Display * const dpy = gc->currentDpy;
1931     const GLuint cmdlen = 36;
1932     (void) dpy;
1933     emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
1934     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1935     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1936     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1937     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1938     gc->pc += cmdlen;
1939     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1940 }
1941
1942 #define X_GLrop_Vertex4dv 73
1943 void
1944 __indirect_glVertex4dv(const GLdouble * v)
1945 {
1946     generic_32_byte( X_GLrop_Vertex4dv, v );
1947 }
1948
1949 #define X_GLrop_Vertex4fv 74
1950 void
1951 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1952 {
1953     __GLXcontext * const gc = __glXGetCurrentContext();
1954     Display * const dpy = gc->currentDpy;
1955     const GLuint cmdlen = 20;
1956     (void) dpy;
1957     emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
1958     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1959     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1960     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1961     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1962     gc->pc += cmdlen;
1963     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1964 }
1965
1966 #define X_GLrop_Vertex4fv 74
1967 void
1968 __indirect_glVertex4fv(const GLfloat * v)
1969 {
1970     generic_16_byte( X_GLrop_Vertex4fv, v );
1971 }
1972
1973 #define X_GLrop_Vertex4iv 75
1974 void
1975 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
1976 {
1977     __GLXcontext * const gc = __glXGetCurrentContext();
1978     Display * const dpy = gc->currentDpy;
1979     const GLuint cmdlen = 20;
1980     (void) dpy;
1981     emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
1982     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1983     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1984     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1985     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1986     gc->pc += cmdlen;
1987     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1988 }
1989
1990 #define X_GLrop_Vertex4iv 75
1991 void
1992 __indirect_glVertex4iv(const GLint * v)
1993 {
1994     generic_16_byte( X_GLrop_Vertex4iv, v );
1995 }
1996
1997 #define X_GLrop_Vertex4sv 76
1998 void
1999 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2000 {
2001     __GLXcontext * const gc = __glXGetCurrentContext();
2002     Display * const dpy = gc->currentDpy;
2003     const GLuint cmdlen = 12;
2004     (void) dpy;
2005     emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
2006     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
2007     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
2008     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
2009     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
2010     gc->pc += cmdlen;
2011     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2012 }
2013
2014 #define X_GLrop_Vertex4sv 76
2015 void
2016 __indirect_glVertex4sv(const GLshort * v)
2017 {
2018     generic_8_byte( X_GLrop_Vertex4sv, v );
2019 }
2020
2021 #define X_GLrop_ClipPlane 77
2022 void
2023 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
2024 {
2025     __GLXcontext * const gc = __glXGetCurrentContext();
2026     Display * const dpy = gc->currentDpy;
2027     const GLuint cmdlen = 40;
2028     (void) dpy;
2029     emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
2030     (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
2031     (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
2032     gc->pc += cmdlen;
2033     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2034 }
2035
2036 #define X_GLrop_ColorMaterial 78
2037 void
2038 __indirect_glColorMaterial(GLenum face, GLenum mode)
2039 {
2040     __GLXcontext * const gc = __glXGetCurrentContext();
2041     Display * const dpy = gc->currentDpy;
2042     const GLuint cmdlen = 12;
2043     (void) dpy;
2044     emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
2045     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2046     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2047     gc->pc += cmdlen;
2048     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2049 }
2050
2051 #define X_GLrop_CullFace 79
2052 void
2053 __indirect_glCullFace(GLenum mode)
2054 {
2055     __GLXcontext * const gc = __glXGetCurrentContext();
2056     Display * const dpy = gc->currentDpy;
2057     const GLuint cmdlen = 8;
2058     (void) dpy;
2059     emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
2060     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2061     gc->pc += cmdlen;
2062     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2063 }
2064
2065 #define X_GLrop_Fogf 80
2066 void
2067 __indirect_glFogf(GLenum pname, GLfloat param)
2068 {
2069     __GLXcontext * const gc = __glXGetCurrentContext();
2070     Display * const dpy = gc->currentDpy;
2071     const GLuint cmdlen = 12;
2072     (void) dpy;
2073     emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2074     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2075     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2076     gc->pc += cmdlen;
2077     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2078 }
2079
2080 #define X_GLrop_Fogfv 81
2081 void
2082 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2083 {
2084     __GLXcontext * const gc = __glXGetCurrentContext();
2085     Display * const dpy = gc->currentDpy;
2086     const GLuint compsize = __glFogfv_size(pname);
2087     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2088     (void) dpy;
2089     emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2090     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2091     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2092     gc->pc += cmdlen;
2093     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2094 }
2095
2096 #define X_GLrop_Fogi 82
2097 void
2098 __indirect_glFogi(GLenum pname, GLint param)
2099 {
2100     __GLXcontext * const gc = __glXGetCurrentContext();
2101     Display * const dpy = gc->currentDpy;
2102     const GLuint cmdlen = 12;
2103     (void) dpy;
2104     emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2105     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2106     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2107     gc->pc += cmdlen;
2108     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2109 }
2110
2111 #define X_GLrop_Fogiv 83
2112 void
2113 __indirect_glFogiv(GLenum pname, const GLint * params)
2114 {
2115     __GLXcontext * const gc = __glXGetCurrentContext();
2116     Display * const dpy = gc->currentDpy;
2117     const GLuint compsize = __glFogiv_size(pname);
2118     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2119     (void) dpy;
2120     emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2121     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2122     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2123     gc->pc += cmdlen;
2124     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2125 }
2126
2127 #define X_GLrop_FrontFace 84
2128 void
2129 __indirect_glFrontFace(GLenum mode)
2130 {
2131     __GLXcontext * const gc = __glXGetCurrentContext();
2132     Display * const dpy = gc->currentDpy;
2133     const GLuint cmdlen = 8;
2134     (void) dpy;
2135     emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2136     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2137     gc->pc += cmdlen;
2138     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2139 }
2140
2141 #define X_GLrop_Hint 85
2142 void
2143 __indirect_glHint(GLenum target, GLenum mode)
2144 {
2145     __GLXcontext * const gc = __glXGetCurrentContext();
2146     Display * const dpy = gc->currentDpy;
2147     const GLuint cmdlen = 12;
2148     (void) dpy;
2149     emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2150     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2151     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2152     gc->pc += cmdlen;
2153     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2154 }
2155
2156 #define X_GLrop_Lightf 86
2157 void
2158 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2159 {
2160     __GLXcontext * const gc = __glXGetCurrentContext();
2161     Display * const dpy = gc->currentDpy;
2162     const GLuint cmdlen = 16;
2163     (void) dpy;
2164     emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2165     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2166     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2167     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2168     gc->pc += cmdlen;
2169     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2170 }
2171
2172 #define X_GLrop_Lightfv 87
2173 void
2174 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2175 {
2176     __GLXcontext * const gc = __glXGetCurrentContext();
2177     Display * const dpy = gc->currentDpy;
2178     const GLuint compsize = __glLightfv_size(pname);
2179     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2180     (void) dpy;
2181     emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2182     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2183     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2184     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2185     gc->pc += cmdlen;
2186     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2187 }
2188
2189 #define X_GLrop_Lighti 88
2190 void
2191 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2192 {
2193     __GLXcontext * const gc = __glXGetCurrentContext();
2194     Display * const dpy = gc->currentDpy;
2195     const GLuint cmdlen = 16;
2196     (void) dpy;
2197     emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2198     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2199     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2200     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2201     gc->pc += cmdlen;
2202     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2203 }
2204
2205 #define X_GLrop_Lightiv 89
2206 void
2207 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2208 {
2209     __GLXcontext * const gc = __glXGetCurrentContext();
2210     Display * const dpy = gc->currentDpy;
2211     const GLuint compsize = __glLightiv_size(pname);
2212     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2213     (void) dpy;
2214     emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2215     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2216     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2217     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2218     gc->pc += cmdlen;
2219     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2220 }
2221
2222 #define X_GLrop_LightModelf 90
2223 void
2224 __indirect_glLightModelf(GLenum pname, GLfloat param)
2225 {
2226     __GLXcontext * const gc = __glXGetCurrentContext();
2227     Display * const dpy = gc->currentDpy;
2228     const GLuint cmdlen = 12;
2229     (void) dpy;
2230     emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2231     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2232     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2233     gc->pc += cmdlen;
2234     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2235 }
2236
2237 #define X_GLrop_LightModelfv 91
2238 void
2239 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2240 {
2241     __GLXcontext * const gc = __glXGetCurrentContext();
2242     Display * const dpy = gc->currentDpy;
2243     const GLuint compsize = __glLightModelfv_size(pname);
2244     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2245     (void) dpy;
2246     emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2247     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2248     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2249     gc->pc += cmdlen;
2250     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2251 }
2252
2253 #define X_GLrop_LightModeli 92
2254 void
2255 __indirect_glLightModeli(GLenum pname, GLint param)
2256 {
2257     __GLXcontext * const gc = __glXGetCurrentContext();
2258     Display * const dpy = gc->currentDpy;
2259     const GLuint cmdlen = 12;
2260     (void) dpy;
2261     emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2262     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2263     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2264     gc->pc += cmdlen;
2265     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2266 }
2267
2268 #define X_GLrop_LightModeliv 93
2269 void
2270 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2271 {
2272     __GLXcontext * const gc = __glXGetCurrentContext();
2273     Display * const dpy = gc->currentDpy;
2274     const GLuint compsize = __glLightModeliv_size(pname);
2275     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2276     (void) dpy;
2277     emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2278     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2279     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2280     gc->pc += cmdlen;
2281     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2282 }
2283
2284 #define X_GLrop_LineStipple 94
2285 void
2286 __indirect_glLineStipple(GLint factor, GLushort pattern)
2287 {
2288     __GLXcontext * const gc = __glXGetCurrentContext();
2289     Display * const dpy = gc->currentDpy;
2290     const GLuint cmdlen = 12;
2291     (void) dpy;
2292     emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2293     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
2294     (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
2295     gc->pc += cmdlen;
2296     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2297 }
2298
2299 #define X_GLrop_LineWidth 95
2300 void
2301 __indirect_glLineWidth(GLfloat width)
2302 {
2303     __GLXcontext * const gc = __glXGetCurrentContext();
2304     Display * const dpy = gc->currentDpy;
2305     const GLuint cmdlen = 8;
2306     (void) dpy;
2307     emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2308     (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
2309     gc->pc += cmdlen;
2310     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2311 }
2312
2313 #define X_GLrop_Materialf 96
2314 void
2315 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2316 {
2317     __GLXcontext * const gc = __glXGetCurrentContext();
2318     Display * const dpy = gc->currentDpy;
2319     const GLuint cmdlen = 16;
2320     (void) dpy;
2321     emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2322     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2323     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2324     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2325     gc->pc += cmdlen;
2326     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2327 }
2328
2329 #define X_GLrop_Materialfv 97
2330 void
2331 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2332 {
2333     __GLXcontext * const gc = __glXGetCurrentContext();
2334     Display * const dpy = gc->currentDpy;
2335     const GLuint compsize = __glMaterialfv_size(pname);
2336     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2337     (void) dpy;
2338     emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2339     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2340     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2341     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2342     gc->pc += cmdlen;
2343     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2344 }
2345
2346 #define X_GLrop_Materiali 98
2347 void
2348 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2349 {
2350     __GLXcontext * const gc = __glXGetCurrentContext();
2351     Display * const dpy = gc->currentDpy;
2352     const GLuint cmdlen = 16;
2353     (void) dpy;
2354     emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2355     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2356     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2357     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2358     gc->pc += cmdlen;
2359     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2360 }
2361
2362 #define X_GLrop_Materialiv 99
2363 void
2364 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2365 {
2366     __GLXcontext * const gc = __glXGetCurrentContext();
2367     Display * const dpy = gc->currentDpy;
2368     const GLuint compsize = __glMaterialiv_size(pname);
2369     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2370     (void) dpy;
2371     emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2372     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2373     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2374     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2375     gc->pc += cmdlen;
2376     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2377 }
2378
2379 #define X_GLrop_PointSize 100
2380 void
2381 __indirect_glPointSize(GLfloat size)
2382 {
2383     __GLXcontext * const gc = __glXGetCurrentContext();
2384     Display * const dpy = gc->currentDpy;
2385     const GLuint cmdlen = 8;
2386     (void) dpy;
2387     emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2388     (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
2389     gc->pc += cmdlen;
2390     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2391 }
2392
2393 #define X_GLrop_PolygonMode 101
2394 void
2395 __indirect_glPolygonMode(GLenum face, GLenum mode)
2396 {
2397     __GLXcontext * const gc = __glXGetCurrentContext();
2398     Display * const dpy = gc->currentDpy;
2399     const GLuint cmdlen = 12;
2400     (void) dpy;
2401     emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2402     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2403     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2404     gc->pc += cmdlen;
2405     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2406 }
2407
2408 #define X_GLrop_Scissor 103
2409 void
2410 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2411 {
2412     __GLXcontext * const gc = __glXGetCurrentContext();
2413     Display * const dpy = gc->currentDpy;
2414     const GLuint cmdlen = 20;
2415     (void) dpy;
2416     emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2417     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
2418     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
2419     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
2420     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
2421     gc->pc += cmdlen;
2422     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2423 }
2424
2425 #define X_GLrop_ShadeModel 104
2426 void
2427 __indirect_glShadeModel(GLenum mode)
2428 {
2429     __GLXcontext * const gc = __glXGetCurrentContext();
2430     Display * const dpy = gc->currentDpy;
2431     const GLuint cmdlen = 8;
2432     (void) dpy;
2433     emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2434     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2435     gc->pc += cmdlen;
2436     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2437 }
2438
2439 #define X_GLrop_TexParameterf 105
2440 void
2441 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2442 {
2443     __GLXcontext * const gc = __glXGetCurrentContext();
2444     Display * const dpy = gc->currentDpy;
2445     const GLuint cmdlen = 16;
2446     (void) dpy;
2447     emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2448     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2449     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2450     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2451     gc->pc += cmdlen;
2452     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2453 }
2454
2455 #define X_GLrop_TexParameterfv 106
2456 void
2457 __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
2458 {
2459     __GLXcontext * const gc = __glXGetCurrentContext();
2460     Display * const dpy = gc->currentDpy;
2461     const GLuint compsize = __glTexParameterfv_size(pname);
2462     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2463     (void) dpy;
2464     emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2465     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2466     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2467     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2468     gc->pc += cmdlen;
2469     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2470 }
2471
2472 #define X_GLrop_TexParameteri 107
2473 void
2474 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2475 {
2476     __GLXcontext * const gc = __glXGetCurrentContext();
2477     Display * const dpy = gc->currentDpy;
2478     const GLuint cmdlen = 16;
2479     (void) dpy;
2480     emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2481     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2482     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2483     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2484     gc->pc += cmdlen;
2485     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2486 }
2487
2488 #define X_GLrop_TexParameteriv 108
2489 void
2490 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2491 {
2492     __GLXcontext * const gc = __glXGetCurrentContext();
2493     Display * const dpy = gc->currentDpy;
2494     const GLuint compsize = __glTexParameteriv_size(pname);
2495     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2496     (void) dpy;
2497     emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2498     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2499     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2500     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2501     gc->pc += cmdlen;
2502     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2503 }
2504
2505 #define X_GLrop_TexEnvf 111
2506 void
2507 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2508 {
2509     __GLXcontext * const gc = __glXGetCurrentContext();
2510     Display * const dpy = gc->currentDpy;
2511     const GLuint cmdlen = 16;
2512     (void) dpy;
2513     emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2514     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2515     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2516     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2517     gc->pc += cmdlen;
2518     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2519 }
2520
2521 #define X_GLrop_TexEnvfv 112
2522 void
2523 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2524 {
2525     __GLXcontext * const gc = __glXGetCurrentContext();
2526     Display * const dpy = gc->currentDpy;
2527     const GLuint compsize = __glTexEnvfv_size(pname);
2528     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2529     (void) dpy;
2530     emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2531     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2532     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2533     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2534     gc->pc += cmdlen;
2535     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2536 }
2537
2538 #define X_GLrop_TexEnvi 113
2539 void
2540 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2541 {
2542     __GLXcontext * const gc = __glXGetCurrentContext();
2543     Display * const dpy = gc->currentDpy;
2544     const GLuint cmdlen = 16;
2545     (void) dpy;
2546     emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2547     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2548     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2549     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2550     gc->pc += cmdlen;
2551     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2552 }
2553
2554 #define X_GLrop_TexEnviv 114
2555 void
2556 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2557 {
2558     __GLXcontext * const gc = __glXGetCurrentContext();
2559     Display * const dpy = gc->currentDpy;
2560     const GLuint compsize = __glTexEnviv_size(pname);
2561     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2562     (void) dpy;
2563     emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2564     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2565     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2566     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2567     gc->pc += cmdlen;
2568     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2569 }
2570
2571 #define X_GLrop_TexGend 115
2572 void
2573 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2574 {
2575     __GLXcontext * const gc = __glXGetCurrentContext();
2576     Display * const dpy = gc->currentDpy;
2577     const GLuint cmdlen = 20;
2578     (void) dpy;
2579     emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2580     (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
2581     (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
2582     (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
2583     gc->pc += cmdlen;
2584     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2585 }
2586
2587 #define X_GLrop_TexGendv 116
2588 void
2589 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2590 {
2591     __GLXcontext * const gc = __glXGetCurrentContext();
2592     Display * const dpy = gc->currentDpy;
2593     const GLuint compsize = __glTexGendv_size(pname);
2594     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2595     (void) dpy;
2596     emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2597     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2598     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2599     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
2600     gc->pc += cmdlen;
2601     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2602 }
2603
2604 #define X_GLrop_TexGenf 117
2605 void
2606 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2607 {
2608     __GLXcontext * const gc = __glXGetCurrentContext();
2609     Display * const dpy = gc->currentDpy;
2610     const GLuint cmdlen = 16;
2611     (void) dpy;
2612     emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2613     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2614     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2615     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2616     gc->pc += cmdlen;
2617     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2618 }
2619
2620 #define X_GLrop_TexGenfv 118
2621 void
2622 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2623 {
2624     __GLXcontext * const gc = __glXGetCurrentContext();
2625     Display * const dpy = gc->currentDpy;
2626     const GLuint compsize = __glTexGenfv_size(pname);
2627     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2628     (void) dpy;
2629     emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2630     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2631     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2632     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2633     gc->pc += cmdlen;
2634     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2635 }
2636
2637 #define X_GLrop_TexGeni 119
2638 void
2639 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2640 {
2641     __GLXcontext * const gc = __glXGetCurrentContext();
2642     Display * const dpy = gc->currentDpy;
2643     const GLuint cmdlen = 16;
2644     (void) dpy;
2645     emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2646     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2647     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2648     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2649     gc->pc += cmdlen;
2650     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2651 }
2652
2653 #define X_GLrop_TexGeniv 120
2654 void
2655 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2656 {
2657     __GLXcontext * const gc = __glXGetCurrentContext();
2658     Display * const dpy = gc->currentDpy;
2659     const GLuint compsize = __glTexGeniv_size(pname);
2660     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2661     (void) dpy;
2662     emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2663     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2664     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2665     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2666     gc->pc += cmdlen;
2667     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2668 }
2669
2670 #define X_GLrop_InitNames 121
2671 void
2672 __indirect_glInitNames(void)
2673 {
2674     __GLXcontext * const gc = __glXGetCurrentContext();
2675     Display * const dpy = gc->currentDpy;
2676     const GLuint cmdlen = 4;
2677     (void) dpy;
2678     emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2679     gc->pc += cmdlen;
2680     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2681 }
2682
2683 #define X_GLrop_LoadName 122
2684 void
2685 __indirect_glLoadName(GLuint name)
2686 {
2687     __GLXcontext * const gc = __glXGetCurrentContext();
2688     Display * const dpy = gc->currentDpy;
2689     const GLuint cmdlen = 8;
2690     (void) dpy;
2691     emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2692     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2693     gc->pc += cmdlen;
2694     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2695 }
2696
2697 #define X_GLrop_PassThrough 123
2698 void
2699 __indirect_glPassThrough(GLfloat token)
2700 {
2701     __GLXcontext * const gc = __glXGetCurrentContext();
2702     Display * const dpy = gc->currentDpy;
2703     const GLuint cmdlen = 8;
2704     (void) dpy;
2705     emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2706     (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
2707     gc->pc += cmdlen;
2708     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2709 }
2710
2711 #define X_GLrop_PopName 124
2712 void
2713 __indirect_glPopName(void)
2714 {
2715     __GLXcontext * const gc = __glXGetCurrentContext();
2716     Display * const dpy = gc->currentDpy;
2717     const GLuint cmdlen = 4;
2718     (void) dpy;
2719     emit_header(gc->pc, X_GLrop_PopName, cmdlen);
2720     gc->pc += cmdlen;
2721     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2722 }
2723
2724 #define X_GLrop_PushName 125
2725 void
2726 __indirect_glPushName(GLuint name)
2727 {
2728     __GLXcontext * const gc = __glXGetCurrentContext();
2729     Display * const dpy = gc->currentDpy;
2730     const GLuint cmdlen = 8;
2731     (void) dpy;
2732     emit_header(gc->pc, X_GLrop_PushName, cmdlen);
2733     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2734     gc->pc += cmdlen;
2735     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2736 }
2737
2738 #define X_GLrop_DrawBuffer 126
2739 void
2740 __indirect_glDrawBuffer(GLenum mode)
2741 {
2742     __GLXcontext * const gc = __glXGetCurrentContext();
2743     Display * const dpy = gc->currentDpy;
2744     const GLuint cmdlen = 8;
2745     (void) dpy;
2746     emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
2747     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2748     gc->pc += cmdlen;
2749     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2750 }
2751
2752 #define X_GLrop_Clear 127
2753 void
2754 __indirect_glClear(GLbitfield mask)
2755 {
2756     __GLXcontext * const gc = __glXGetCurrentContext();
2757     Display * const dpy = gc->currentDpy;
2758     const GLuint cmdlen = 8;
2759     (void) dpy;
2760     emit_header(gc->pc, X_GLrop_Clear, cmdlen);
2761     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2762     gc->pc += cmdlen;
2763     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2764 }
2765
2766 #define X_GLrop_ClearAccum 128
2767 void
2768 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
2769 {
2770     __GLXcontext * const gc = __glXGetCurrentContext();
2771     Display * const dpy = gc->currentDpy;
2772     const GLuint cmdlen = 20;
2773     (void) dpy;
2774     emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
2775     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2776     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2777     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2778     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2779     gc->pc += cmdlen;
2780     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2781 }
2782
2783 #define X_GLrop_ClearIndex 129
2784 void
2785 __indirect_glClearIndex(GLfloat c)
2786 {
2787     __GLXcontext * const gc = __glXGetCurrentContext();
2788     Display * const dpy = gc->currentDpy;
2789     const GLuint cmdlen = 8;
2790     (void) dpy;
2791     emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
2792     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
2793     gc->pc += cmdlen;
2794     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2795 }
2796
2797 #define X_GLrop_ClearColor 130
2798 void
2799 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2800 {
2801     __GLXcontext * const gc = __glXGetCurrentContext();
2802     Display * const dpy = gc->currentDpy;
2803     const GLuint cmdlen = 20;
2804     (void) dpy;
2805     emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
2806     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2807     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2808     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2809     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2810     gc->pc += cmdlen;
2811     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2812 }
2813
2814 #define X_GLrop_ClearStencil 131
2815 void
2816 __indirect_glClearStencil(GLint s)
2817 {
2818     __GLXcontext * const gc = __glXGetCurrentContext();
2819     Display * const dpy = gc->currentDpy;
2820     const GLuint cmdlen = 8;
2821     (void) dpy;
2822     emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
2823     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
2824     gc->pc += cmdlen;
2825     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2826 }
2827
2828 #define X_GLrop_ClearDepth 132
2829 void
2830 __indirect_glClearDepth(GLclampd depth)
2831 {
2832     __GLXcontext * const gc = __glXGetCurrentContext();
2833     Display * const dpy = gc->currentDpy;
2834     const GLuint cmdlen = 12;
2835     (void) dpy;
2836     emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
2837     (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
2838     gc->pc += cmdlen;
2839     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2840 }
2841
2842 #define X_GLrop_StencilMask 133
2843 void
2844 __indirect_glStencilMask(GLuint mask)
2845 {
2846     __GLXcontext * const gc = __glXGetCurrentContext();
2847     Display * const dpy = gc->currentDpy;
2848     const GLuint cmdlen = 8;
2849     (void) dpy;
2850     emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
2851     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2852     gc->pc += cmdlen;
2853     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2854 }
2855
2856 #define X_GLrop_ColorMask 134
2857 void
2858 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
2859 {
2860     __GLXcontext * const gc = __glXGetCurrentContext();
2861     Display * const dpy = gc->currentDpy;
2862     const GLuint cmdlen = 8;
2863     (void) dpy;
2864     emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
2865     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
2866     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
2867     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
2868     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
2869     gc->pc += cmdlen;
2870     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2871 }
2872
2873 #define X_GLrop_DepthMask 135
2874 void
2875 __indirect_glDepthMask(GLboolean flag)
2876 {
2877     __GLXcontext * const gc = __glXGetCurrentContext();
2878     Display * const dpy = gc->currentDpy;
2879     const GLuint cmdlen = 8;
2880     (void) dpy;
2881     emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
2882     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
2883     gc->pc += cmdlen;
2884     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2885 }
2886
2887 #define X_GLrop_IndexMask 136
2888 void
2889 __indirect_glIndexMask(GLuint mask)
2890 {
2891     __GLXcontext * const gc = __glXGetCurrentContext();
2892     Display * const dpy = gc->currentDpy;
2893     const GLuint cmdlen = 8;
2894     (void) dpy;
2895     emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
2896     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2897     gc->pc += cmdlen;
2898     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2899 }
2900
2901 #define X_GLrop_Accum 137
2902 void
2903 __indirect_glAccum(GLenum op, GLfloat value)
2904 {
2905     __GLXcontext * const gc = __glXGetCurrentContext();
2906     Display * const dpy = gc->currentDpy;
2907     const GLuint cmdlen = 12;
2908     (void) dpy;
2909     emit_header(gc->pc, X_GLrop_Accum, cmdlen);
2910     (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
2911     (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
2912     gc->pc += cmdlen;
2913     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2914 }
2915
2916 #define X_GLrop_PopAttrib 141
2917 void
2918 __indirect_glPopAttrib(void)
2919 {
2920     __GLXcontext * const gc = __glXGetCurrentContext();
2921     Display * const dpy = gc->currentDpy;
2922     const GLuint cmdlen = 4;
2923     (void) dpy;
2924     emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
2925     gc->pc += cmdlen;
2926     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2927 }
2928
2929 #define X_GLrop_PushAttrib 142
2930 void
2931 __indirect_glPushAttrib(GLbitfield mask)
2932 {
2933     __GLXcontext * const gc = __glXGetCurrentContext();
2934     Display * const dpy = gc->currentDpy;
2935     const GLuint cmdlen = 8;
2936     (void) dpy;
2937     emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
2938     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2939     gc->pc += cmdlen;
2940     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2941 }
2942
2943 #define X_GLrop_MapGrid1d 147
2944 void
2945 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2946 {
2947     __GLXcontext * const gc = __glXGetCurrentContext();
2948     Display * const dpy = gc->currentDpy;
2949     const GLuint cmdlen = 24;
2950     (void) dpy;
2951     emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
2952     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2953     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2954     (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
2955     gc->pc += cmdlen;
2956     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2957 }
2958
2959 #define X_GLrop_MapGrid1f 148
2960 void
2961 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2962 {
2963     __GLXcontext * const gc = __glXGetCurrentContext();
2964     Display * const dpy = gc->currentDpy;
2965     const GLuint cmdlen = 16;
2966     (void) dpy;
2967     emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
2968     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2969     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2970     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2971     gc->pc += cmdlen;
2972     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2973 }
2974
2975 #define X_GLrop_MapGrid2d 149
2976 void
2977 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
2978 {
2979     __GLXcontext * const gc = __glXGetCurrentContext();
2980     Display * const dpy = gc->currentDpy;
2981     const GLuint cmdlen = 44;
2982     (void) dpy;
2983     emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
2984     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2985     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2986     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
2987     (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
2988     (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
2989     (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
2990     gc->pc += cmdlen;
2991     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2992 }
2993
2994 #define X_GLrop_MapGrid2f 150
2995 void
2996 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2997 {
2998     __GLXcontext * const gc = __glXGetCurrentContext();
2999     Display * const dpy = gc->currentDpy;
3000     const GLuint cmdlen = 28;
3001     (void) dpy;
3002     emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
3003     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
3004     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
3005     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
3006     (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
3007     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
3008     (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
3009     gc->pc += cmdlen;
3010     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3011 }
3012
3013 #define X_GLrop_EvalCoord1dv 151
3014 void
3015 __indirect_glEvalCoord1d(GLdouble u)
3016 {
3017     __GLXcontext * const gc = __glXGetCurrentContext();
3018     Display * const dpy = gc->currentDpy;
3019     const GLuint cmdlen = 12;
3020     (void) dpy;
3021     emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
3022     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
3023     gc->pc += cmdlen;
3024     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3025 }
3026
3027 #define X_GLrop_EvalCoord1dv 151
3028 void
3029 __indirect_glEvalCoord1dv(const GLdouble * u)
3030 {
3031     generic_8_byte( X_GLrop_EvalCoord1dv, u );
3032 }
3033
3034 #define X_GLrop_EvalCoord1fv 152
3035 void
3036 __indirect_glEvalCoord1f(GLfloat u)
3037 {
3038     __GLXcontext * const gc = __glXGetCurrentContext();
3039     Display * const dpy = gc->currentDpy;
3040     const GLuint cmdlen = 8;
3041     (void) dpy;
3042     emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
3043     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
3044     gc->pc += cmdlen;
3045     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3046 }
3047
3048 #define X_GLrop_EvalCoord1fv 152
3049 void
3050 __indirect_glEvalCoord1fv(const GLfloat * u)
3051 {
3052     generic_4_byte( X_GLrop_EvalCoord1fv, u );
3053 }
3054
3055 #define X_GLrop_EvalCoord2dv 153
3056 void
3057 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
3058 {
3059     __GLXcontext * const gc = __glXGetCurrentContext();
3060     Display * const dpy = gc->currentDpy;
3061     const GLuint cmdlen = 20;
3062     (void) dpy;
3063     emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
3064     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
3065     (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
3066     gc->pc += cmdlen;
3067     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3068 }
3069
3070 #define X_GLrop_EvalCoord2dv 153
3071 void
3072 __indirect_glEvalCoord2dv(const GLdouble * u)
3073 {
3074     generic_16_byte( X_GLrop_EvalCoord2dv, u );
3075 }
3076
3077 #define X_GLrop_EvalCoord2fv 154
3078 void
3079 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
3080 {
3081     __GLXcontext * const gc = __glXGetCurrentContext();
3082     Display * const dpy = gc->currentDpy;
3083     const GLuint cmdlen = 12;
3084     (void) dpy;
3085     emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
3086     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
3087     (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
3088     gc->pc += cmdlen;
3089     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3090 }
3091
3092 #define X_GLrop_EvalCoord2fv 154
3093 void
3094 __indirect_glEvalCoord2fv(const GLfloat * u)
3095 {
3096     generic_8_byte( X_GLrop_EvalCoord2fv, u );
3097 }
3098
3099 #define X_GLrop_EvalMesh1 155
3100 void
3101 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
3102 {
3103     __GLXcontext * const gc = __glXGetCurrentContext();
3104     Display * const dpy = gc->currentDpy;
3105     const GLuint cmdlen = 16;
3106     (void) dpy;
3107     emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
3108     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3109     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
3110     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
3111     gc->pc += cmdlen;
3112     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3113 }
3114
3115 #define X_GLrop_EvalPoint1 156
3116 void
3117 __indirect_glEvalPoint1(GLint i)
3118 {
3119     __GLXcontext * const gc = __glXGetCurrentContext();
3120     Display * const dpy = gc->currentDpy;
3121     const GLuint cmdlen = 8;
3122     (void) dpy;
3123     emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3124     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3125     gc->pc += cmdlen;
3126     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3127 }
3128
3129 #define X_GLrop_EvalMesh2 157
3130 void
3131 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3132 {
3133     __GLXcontext * const gc = __glXGetCurrentContext();
3134     Display * const dpy = gc->currentDpy;
3135     const GLuint cmdlen = 24;
3136     (void) dpy;
3137     emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3138     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3139     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
3140     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
3141     (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
3142     (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
3143     gc->pc += cmdlen;
3144     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3145 }
3146
3147 #define X_GLrop_EvalPoint2 158
3148 void
3149 __indirect_glEvalPoint2(GLint i, GLint j)
3150 {
3151     __GLXcontext * const gc = __glXGetCurrentContext();
3152     Display * const dpy = gc->currentDpy;
3153     const GLuint cmdlen = 12;
3154     (void) dpy;
3155     emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3156     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
3157     (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
3158     gc->pc += cmdlen;
3159     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3160 }
3161
3162 #define X_GLrop_AlphaFunc 159
3163 void
3164 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3165 {
3166     __GLXcontext * const gc = __glXGetCurrentContext();
3167     Display * const dpy = gc->currentDpy;
3168     const GLuint cmdlen = 12;
3169     (void) dpy;
3170     emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3171     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3172     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3173     gc->pc += cmdlen;
3174     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3175 }
3176
3177 #define X_GLrop_BlendFunc 160
3178 void
3179 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3180 {
3181     __GLXcontext * const gc = __glXGetCurrentContext();
3182     Display * const dpy = gc->currentDpy;
3183     const GLuint cmdlen = 12;
3184     (void) dpy;
3185     emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3186     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
3187     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
3188     gc->pc += cmdlen;
3189     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3190 }
3191
3192 #define X_GLrop_LogicOp 161
3193 void
3194 __indirect_glLogicOp(GLenum opcode)
3195 {
3196     __GLXcontext * const gc = __glXGetCurrentContext();
3197     Display * const dpy = gc->currentDpy;
3198     const GLuint cmdlen = 8;
3199     (void) dpy;
3200     emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3201     (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
3202     gc->pc += cmdlen;
3203     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3204 }
3205
3206 #define X_GLrop_StencilFunc 162
3207 void
3208 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3209 {
3210     __GLXcontext * const gc = __glXGetCurrentContext();
3211     Display * const dpy = gc->currentDpy;
3212     const GLuint cmdlen = 16;
3213     (void) dpy;
3214     emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3215     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3216     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
3217     (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
3218     gc->pc += cmdlen;
3219     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3220 }
3221
3222 #define X_GLrop_StencilOp 163
3223 void
3224 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3225 {
3226     __GLXcontext * const gc = __glXGetCurrentContext();
3227     Display * const dpy = gc->currentDpy;
3228     const GLuint cmdlen = 16;
3229     (void) dpy;
3230     emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3231     (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
3232     (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
3233     (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
3234     gc->pc += cmdlen;
3235     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3236 }
3237
3238 #define X_GLrop_DepthFunc 164
3239 void
3240 __indirect_glDepthFunc(GLenum func)
3241 {
3242     __GLXcontext * const gc = __glXGetCurrentContext();
3243     Display * const dpy = gc->currentDpy;
3244     const GLuint cmdlen = 8;
3245     (void) dpy;
3246     emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3247     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
3248     gc->pc += cmdlen;
3249     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3250 }
3251
3252 #define X_GLrop_PixelZoom 165
3253 void
3254 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3255 {
3256     __GLXcontext * const gc = __glXGetCurrentContext();
3257     Display * const dpy = gc->currentDpy;
3258     const GLuint cmdlen = 12;
3259     (void) dpy;
3260     emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3261     (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
3262     (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
3263     gc->pc += cmdlen;
3264     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3265 }
3266
3267 #define X_GLrop_PixelTransferf 166
3268 void
3269 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3270 {
3271     __GLXcontext * const gc = __glXGetCurrentContext();
3272     Display * const dpy = gc->currentDpy;
3273     const GLuint cmdlen = 12;
3274     (void) dpy;
3275     emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3276     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3277     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
3278     gc->pc += cmdlen;
3279     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3280 }
3281
3282 #define X_GLrop_PixelTransferi 167
3283 void
3284 __indirect_glPixelTransferi(GLenum pname, GLint param)
3285 {
3286     __GLXcontext * const gc = __glXGetCurrentContext();
3287     Display * const dpy = gc->currentDpy;
3288     const GLuint cmdlen = 12;
3289     (void) dpy;
3290     emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3291     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
3292     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
3293     gc->pc += cmdlen;
3294     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3295 }
3296
3297 #define X_GLrop_PixelMapfv 168
3298 void
3299 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3300 {
3301     __GLXcontext * const gc = __glXGetCurrentContext();
3302     Display * const dpy = gc->currentDpy;
3303     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3304     if (mapsize < 0) return;
3305     if (dpy == NULL) return;
3306     if ( ((gc->pc + cmdlen) > gc->bufEnd)
3307          || (cmdlen > gc->maxSmallRenderCommandSize)) {
3308         (void) __glXFlushRenderBuffer(gc, gc->pc);
3309     }
3310     if (cmdlen <= gc->maxSmallRenderCommandSize) {
3311         emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3312         (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3313         (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3314         (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3315         gc->pc += cmdlen;
3316         if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3317     }
3318     else {
3319         const GLint op = X_GLrop_PixelMapfv;
3320         const GLuint cmdlenLarge = cmdlen + 4;
3321         (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3322         (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3323         (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3324         (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3325         __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
3326     }
3327 }
3328
3329 #define X_GLrop_PixelMapuiv 169
3330 void
3331 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3332 {
3333     __GLXcontext * const gc = __glXGetCurrentContext();
3334     Display * const dpy = gc->currentDpy;
3335     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3336     if (mapsize < 0) return;
3337     if (dpy == NULL) return;
3338     if ( ((gc->pc + cmdlen) > gc->bufEnd)
3339          || (cmdlen > gc->maxSmallRenderCommandSize)) {
3340         (void) __glXFlushRenderBuffer(gc, gc->pc);
3341     }
3342     if (cmdlen <= gc->maxSmallRenderCommandSize) {
3343         emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3344         (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3345         (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3346         (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3347         gc->pc += cmdlen;
3348         if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3349     }
3350     else {
3351         const GLint op = X_GLrop_PixelMapuiv;
3352         const GLuint cmdlenLarge = cmdlen + 4;
3353         (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3354         (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3355         (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3356         (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3357         __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
3358     }
3359 }
3360
3361 #define X_GLrop_PixelMapusv 170
3362 void
3363 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3364 {
3365     __GLXcontext * const gc = __glXGetCurrentContext();
3366     Display * const dpy = gc->currentDpy;
3367     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3368     if (mapsize < 0) return;
3369     if (dpy == NULL) return;
3370     if ( ((gc->pc + cmdlen) > gc->bufEnd)
3371          || (cmdlen > gc->maxSmallRenderCommandSize)) {
3372         (void) __glXFlushRenderBuffer(gc, gc->pc);
3373     }
3374     if (cmdlen <= gc->maxSmallRenderCommandSize) {
3375         emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3376         (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3377         (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3378         (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
3379         gc->pc += cmdlen;
3380         if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3381     }
3382     else {
3383         const GLint op = X_GLrop_PixelMapusv;
3384         const GLuint cmdlenLarge = cmdlen + 4;
3385         (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
3386         (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
3387         (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
3388         (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
3389         __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 2));
3390     }
3391 }
3392
3393 #define X_GLrop_ReadBuffer 171
3394 void
3395 __indirect_glReadBuffer(GLenum mode)
3396 {
3397     __GLXcontext * const gc = __glXGetCurrentContext();
3398     Display * const dpy = gc->currentDpy;
3399     const GLuint cmdlen = 8;
3400     (void) dpy;
3401     emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3402     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3403     gc->pc += cmdlen;
3404     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3405 }
3406
3407 #define X_GLrop_CopyPixels 172
3408 void
3409 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
3410 {
3411     __GLXcontext * const gc = __glXGetCurrentContext();
3412     Display * const dpy = gc->currentDpy;
3413     const GLuint cmdlen = 24;
3414     (void) dpy;
3415     emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3416     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3417     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3418     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3419     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3420     (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
3421     gc->pc += cmdlen;
3422     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3423 }
3424
3425 #define X_GLsop_GetClipPlane 113
3426 void
3427 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3428 {
3429     __GLXcontext * const gc = __glXGetCurrentContext();
3430     Display * const dpy = gc->currentDpy;
3431     const GLuint cmdlen = 4;
3432     (void) dpy;
3433     if (dpy != NULL) {
3434         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetClipPlane, cmdlen);
3435         (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
3436         (void) read_reply(gc->currentDpy, 8, equation, GL_TRUE);
3437         UnlockDisplay(gc->currentDpy); SyncHandle();
3438     }
3439     return;
3440 }
3441
3442 #define X_GLsop_GetLightfv 118
3443 void
3444 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3445 {
3446     __GLXcontext * const gc = __glXGetCurrentContext();
3447     Display * const dpy = gc->currentDpy;
3448     const GLuint cmdlen = 8;
3449     (void) dpy;
3450     if (dpy != NULL) {
3451         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightfv, cmdlen);
3452         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3453         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3454         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3455         UnlockDisplay(gc->currentDpy); SyncHandle();
3456     }
3457     return;
3458 }
3459
3460 #define X_GLsop_GetLightiv 119
3461 void
3462 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3463 {
3464     __GLXcontext * const gc = __glXGetCurrentContext();
3465     Display * const dpy = gc->currentDpy;
3466     const GLuint cmdlen = 8;
3467     (void) dpy;
3468     if (dpy != NULL) {
3469         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightiv, cmdlen);
3470         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3471         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3472         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3473         UnlockDisplay(gc->currentDpy); SyncHandle();
3474     }
3475     return;
3476 }
3477
3478 #define X_GLsop_GetMapdv 120
3479 void
3480 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3481 {
3482     __GLXcontext * const gc = __glXGetCurrentContext();
3483     Display * const dpy = gc->currentDpy;
3484     const GLuint cmdlen = 8;
3485     (void) dpy;
3486     if (dpy != NULL) {
3487         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapdv, cmdlen);
3488         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3489         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3490         (void) read_reply(gc->currentDpy, 8, v, GL_FALSE);
3491         UnlockDisplay(gc->currentDpy); SyncHandle();
3492     }
3493     return;
3494 }
3495
3496 #define X_GLsop_GetMapfv 121
3497 void
3498 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3499 {
3500     __GLXcontext * const gc = __glXGetCurrentContext();
3501     Display * const dpy = gc->currentDpy;
3502     const GLuint cmdlen = 8;
3503     (void) dpy;
3504     if (dpy != NULL) {
3505         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapfv, cmdlen);
3506         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3507         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3508         (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
3509         UnlockDisplay(gc->currentDpy); SyncHandle();
3510     }
3511     return;
3512 }
3513
3514 #define X_GLsop_GetMapiv 122
3515 void
3516 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
3517 {
3518     __GLXcontext * const gc = __glXGetCurrentContext();
3519     Display * const dpy = gc->currentDpy;
3520     const GLuint cmdlen = 8;
3521     (void) dpy;
3522     if (dpy != NULL) {
3523         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapiv, cmdlen);
3524         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3525         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3526         (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
3527         UnlockDisplay(gc->currentDpy); SyncHandle();
3528     }
3529     return;
3530 }
3531
3532 #define X_GLsop_GetMaterialfv 123
3533 void
3534 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
3535 {
3536     __GLXcontext * const gc = __glXGetCurrentContext();
3537     Display * const dpy = gc->currentDpy;
3538     const GLuint cmdlen = 8;
3539     (void) dpy;
3540     if (dpy != NULL) {
3541         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialfv, cmdlen);
3542         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3543         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3544         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3545         UnlockDisplay(gc->currentDpy); SyncHandle();
3546     }
3547     return;
3548 }
3549
3550 #define X_GLsop_GetMaterialiv 124
3551 void
3552 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
3553 {
3554     __GLXcontext * const gc = __glXGetCurrentContext();
3555     Display * const dpy = gc->currentDpy;
3556     const GLuint cmdlen = 8;
3557     (void) dpy;
3558     if (dpy != NULL) {
3559         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialiv, cmdlen);
3560         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3561         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3562         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3563         UnlockDisplay(gc->currentDpy); SyncHandle();
3564     }
3565     return;
3566 }
3567
3568 #define X_GLsop_GetPixelMapfv 125
3569 void
3570 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
3571 {
3572     __GLXcontext * const gc = __glXGetCurrentContext();
3573     Display * const dpy = gc->currentDpy;
3574     const GLuint cmdlen = 4;
3575     (void) dpy;
3576     if (dpy != NULL) {
3577         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapfv, cmdlen);
3578         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3579         (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
3580         UnlockDisplay(gc->currentDpy); SyncHandle();
3581     }
3582     return;
3583 }
3584
3585 #define X_GLsop_GetPixelMapuiv 126
3586 void
3587 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
3588 {
3589     __GLXcontext * const gc = __glXGetCurrentContext();
3590     Display * const dpy = gc->currentDpy;
3591     const GLuint cmdlen = 4;
3592     (void) dpy;
3593     if (dpy != NULL) {
3594         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapuiv, cmdlen);
3595         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3596         (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
3597         UnlockDisplay(gc->currentDpy); SyncHandle();
3598     }
3599     return;
3600 }
3601
3602 #define X_GLsop_GetPixelMapusv 127
3603 void
3604 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
3605 {
3606     __GLXcontext * const gc = __glXGetCurrentContext();
3607     Display * const dpy = gc->currentDpy;
3608     const GLuint cmdlen = 4;
3609     (void) dpy;
3610     if (dpy != NULL) {
3611         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapusv, cmdlen);
3612         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3613         (void) read_reply(gc->currentDpy, 2, values, GL_FALSE);
3614         UnlockDisplay(gc->currentDpy); SyncHandle();
3615     }
3616     return;
3617 }
3618
3619 #define X_GLsop_GetTexEnvfv 130
3620 void
3621 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
3622 {
3623     __GLXcontext * const gc = __glXGetCurrentContext();
3624     Display * const dpy = gc->currentDpy;
3625     const GLuint cmdlen = 8;
3626     (void) dpy;
3627     if (dpy != NULL) {
3628         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnvfv, cmdlen);
3629         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3630         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3631         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3632         UnlockDisplay(gc->currentDpy); SyncHandle();
3633     }
3634     return;
3635 }
3636
3637 #define X_GLsop_GetTexEnviv 131
3638 void
3639 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
3640 {
3641     __GLXcontext * const gc = __glXGetCurrentContext();
3642     Display * const dpy = gc->currentDpy;
3643     const GLuint cmdlen = 8;
3644     (void) dpy;
3645     if (dpy != NULL) {
3646         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnviv, cmdlen);
3647         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3648         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3649         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3650         UnlockDisplay(gc->currentDpy); SyncHandle();
3651     }
3652     return;
3653 }
3654
3655 #define X_GLsop_GetTexGendv 132
3656 void
3657 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
3658 {
3659     __GLXcontext * const gc = __glXGetCurrentContext();
3660     Display * const dpy = gc->currentDpy;
3661     const GLuint cmdlen = 8;
3662     (void) dpy;
3663     if (dpy != NULL) {
3664         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGendv, cmdlen);
3665         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3666         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3667         (void) read_reply(gc->currentDpy, 8, params, GL_FALSE);
3668         UnlockDisplay(gc->currentDpy); SyncHandle();
3669     }
3670     return;
3671 }
3672
3673 #define X_GLsop_GetTexGenfv 133
3674 void
3675 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
3676 {
3677     __GLXcontext * const gc = __glXGetCurrentContext();
3678     Display * const dpy = gc->currentDpy;
3679     const GLuint cmdlen = 8;
3680     (void) dpy;
3681     if (dpy != NULL) {
3682         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGenfv, cmdlen);
3683         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3684         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3685         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3686         UnlockDisplay(gc->currentDpy); SyncHandle();
3687     }
3688     return;
3689 }
3690
3691 #define X_GLsop_GetTexGeniv 134
3692 void
3693 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
3694 {
3695     __GLXcontext * const gc = __glXGetCurrentContext();
3696     Display * const dpy = gc->currentDpy;
3697     const GLuint cmdlen = 8;
3698     (void) dpy;
3699     if (dpy != NULL) {
3700         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGeniv, cmdlen);
3701         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3702         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3703         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3704         UnlockDisplay(gc->currentDpy); SyncHandle();
3705     }
3706     return;
3707 }
3708
3709 #define X_GLsop_GetTexParameterfv 136
3710 void
3711 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
3712 {
3713     __GLXcontext * const gc = __glXGetCurrentContext();
3714     Display * const dpy = gc->currentDpy;
3715     const GLuint cmdlen = 8;
3716     (void) dpy;
3717     if (dpy != NULL) {
3718         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameterfv, cmdlen);
3719         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3720         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3721         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3722         UnlockDisplay(gc->currentDpy); SyncHandle();
3723     }
3724     return;
3725 }
3726
3727 #define X_GLsop_GetTexParameteriv 137
3728 void
3729 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
3730 {
3731     __GLXcontext * const gc = __glXGetCurrentContext();
3732     Display * const dpy = gc->currentDpy;
3733     const GLuint cmdlen = 8;
3734     (void) dpy;
3735     if (dpy != NULL) {
3736         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameteriv, cmdlen);
3737         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3738         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3739         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3740         UnlockDisplay(gc->currentDpy); SyncHandle();
3741     }
3742     return;
3743 }
3744
3745 #define X_GLsop_GetTexLevelParameterfv 138
3746 void
3747 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
3748 {
3749     __GLXcontext * const gc = __glXGetCurrentContext();
3750     Display * const dpy = gc->currentDpy;
3751     const GLuint cmdlen = 12;
3752     (void) dpy;
3753     if (dpy != NULL) {
3754         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
3755         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3756         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3757         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3758         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3759         UnlockDisplay(gc->currentDpy); SyncHandle();
3760     }
3761     return;
3762 }
3763
3764 #define X_GLsop_GetTexLevelParameteriv 139
3765 void
3766 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
3767 {
3768     __GLXcontext * const gc = __glXGetCurrentContext();
3769     Display * const dpy = gc->currentDpy;
3770     const GLuint cmdlen = 12;
3771     (void) dpy;
3772     if (dpy != NULL) {
3773         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
3774         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3775         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3776         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3777         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
3778         UnlockDisplay(gc->currentDpy); SyncHandle();
3779     }
3780     return;
3781 }
3782
3783 #define X_GLsop_IsList 141
3784 GLboolean
3785 __indirect_glIsList(GLuint list)
3786 {
3787     __GLXcontext * const gc = __glXGetCurrentContext();
3788     Display * const dpy = gc->currentDpy;
3789     GLboolean retval = (GLboolean) 0;
3790     const GLuint cmdlen = 4;
3791     (void) dpy;
3792     if (dpy != NULL) {
3793         GLubyte const * pc = setup_single_request(gc, X_GLsop_IsList, cmdlen);
3794         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
3795         retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
3796         UnlockDisplay(gc->currentDpy); SyncHandle();
3797     }
3798     return retval;
3799 }
3800
3801 #define X_GLrop_DepthRange 174
3802 void
3803 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
3804 {
3805     __GLXcontext * const gc = __glXGetCurrentContext();
3806     Display * const dpy = gc->currentDpy;
3807     const GLuint cmdlen = 20;
3808     (void) dpy;
3809     emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
3810     (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
3811     (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
3812     gc->pc += cmdlen;
3813     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3814 }
3815
3816 #define X_GLrop_Frustum 175
3817 void
3818 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3819 {
3820     __GLXcontext * const gc = __glXGetCurrentContext();
3821     Display * const dpy = gc->currentDpy;
3822     const GLuint cmdlen = 52;
3823     (void) dpy;
3824     emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
3825     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3826     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3827     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3828     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3829     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3830     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3831     gc->pc += cmdlen;
3832     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3833 }
3834
3835 #define X_GLrop_LoadIdentity 176
3836 void
3837 __indirect_glLoadIdentity(void)
3838 {
3839     __GLXcontext * const gc = __glXGetCurrentContext();
3840     Display * const dpy = gc->currentDpy;
3841     const GLuint cmdlen = 4;
3842     (void) dpy;
3843     emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
3844     gc->pc += cmdlen;
3845     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3846 }
3847
3848 #define X_GLrop_LoadMatrixf 177
3849 void
3850 __indirect_glLoadMatrixf(const GLfloat * m)
3851 {
3852     __GLXcontext * const gc = __glXGetCurrentContext();
3853     Display * const dpy = gc->currentDpy;
3854     const GLuint cmdlen = 68;
3855     (void) dpy;
3856     emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
3857     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3858     gc->pc += cmdlen;
3859     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3860 }
3861
3862 #define X_GLrop_LoadMatrixd 178
3863 void
3864 __indirect_glLoadMatrixd(const GLdouble * m)
3865 {
3866     __GLXcontext * const gc = __glXGetCurrentContext();
3867     Display * const dpy = gc->currentDpy;
3868     const GLuint cmdlen = 132;
3869     (void) dpy;
3870     emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
3871     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3872     gc->pc += cmdlen;
3873     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3874 }
3875
3876 #define X_GLrop_MatrixMode 179
3877 void
3878 __indirect_glMatrixMode(GLenum mode)
3879 {
3880     __GLXcontext * const gc = __glXGetCurrentContext();
3881     Display * const dpy = gc->currentDpy;
3882     const GLuint cmdlen = 8;
3883     (void) dpy;
3884     emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
3885     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3886     gc->pc += cmdlen;
3887     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3888 }
3889
3890 #define X_GLrop_MultMatrixf 180
3891 void
3892 __indirect_glMultMatrixf(const GLfloat * m)
3893 {
3894     __GLXcontext * const gc = __glXGetCurrentContext();
3895     Display * const dpy = gc->currentDpy;
3896     const GLuint cmdlen = 68;
3897     (void) dpy;
3898     emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
3899     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3900     gc->pc += cmdlen;
3901     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3902 }
3903
3904 #define X_GLrop_MultMatrixd 181
3905 void
3906 __indirect_glMultMatrixd(const GLdouble * m)
3907 {
3908     __GLXcontext * const gc = __glXGetCurrentContext();
3909     Display * const dpy = gc->currentDpy;
3910     const GLuint cmdlen = 132;
3911     (void) dpy;
3912     emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
3913     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3914     gc->pc += cmdlen;
3915     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3916 }
3917
3918 #define X_GLrop_Ortho 182
3919 void
3920 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3921 {
3922     __GLXcontext * const gc = __glXGetCurrentContext();
3923     Display * const dpy = gc->currentDpy;
3924     const GLuint cmdlen = 52;
3925     (void) dpy;
3926     emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
3927     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3928     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3929     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3930     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3931     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3932     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3933     gc->pc += cmdlen;
3934     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3935 }
3936
3937 #define X_GLrop_PopMatrix 183
3938 void
3939 __indirect_glPopMatrix(void)
3940 {
3941     __GLXcontext * const gc = __glXGetCurrentContext();
3942     Display * const dpy = gc->currentDpy;
3943     const GLuint cmdlen = 4;
3944     (void) dpy;
3945     emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
3946     gc->pc += cmdlen;
3947     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3948 }
3949
3950 #define X_GLrop_PushMatrix 184
3951 void
3952 __indirect_glPushMatrix(void)
3953 {
3954     __GLXcontext * const gc = __glXGetCurrentContext();
3955     Display * const dpy = gc->currentDpy;
3956     const GLuint cmdlen = 4;
3957     (void) dpy;
3958     emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
3959     gc->pc += cmdlen;
3960     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3961 }
3962
3963 #define X_GLrop_Rotated 185
3964 void
3965 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3966 {
3967     __GLXcontext * const gc = __glXGetCurrentContext();
3968     Display * const dpy = gc->currentDpy;
3969     const GLuint cmdlen = 36;
3970     (void) dpy;
3971     emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
3972     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
3973     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
3974     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
3975     (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
3976     gc->pc += cmdlen;
3977     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3978 }
3979
3980 #define X_GLrop_Rotatef 186
3981 void
3982 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3983 {
3984     __GLXcontext * const gc = __glXGetCurrentContext();
3985     Display * const dpy = gc->currentDpy;
3986     const GLuint cmdlen = 20;
3987     (void) dpy;
3988     emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
3989     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
3990     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
3991     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
3992     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
3993     gc->pc += cmdlen;
3994     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3995 }
3996
3997 #define X_GLrop_Scaled 187
3998 void
3999 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
4000 {
4001     __GLXcontext * const gc = __glXGetCurrentContext();
4002     Display * const dpy = gc->currentDpy;
4003     const GLuint cmdlen = 28;
4004     (void) dpy;
4005     emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
4006     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
4007     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
4008     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
4009     gc->pc += cmdlen;
4010     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4011 }
4012
4013 #define X_GLrop_Scalef 188
4014 void
4015 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
4016 {
4017     __GLXcontext * const gc = __glXGetCurrentContext();
4018     Display * const dpy = gc->currentDpy;
4019     const GLuint cmdlen = 16;
4020     (void) dpy;
4021     emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
4022     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4023     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4024     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4025     gc->pc += cmdlen;
4026     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4027 }
4028
4029 #define X_GLrop_Translated 189
4030 void
4031 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4032 {
4033     __GLXcontext * const gc = __glXGetCurrentContext();
4034     Display * const dpy = gc->currentDpy;
4035     const GLuint cmdlen = 28;
4036     (void) dpy;
4037     emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4038     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
4039     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
4040     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
4041     gc->pc += cmdlen;
4042     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4043 }
4044
4045 #define X_GLrop_Translatef 190
4046 void
4047 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4048 {
4049     __GLXcontext * const gc = __glXGetCurrentContext();
4050     Display * const dpy = gc->currentDpy;
4051     const GLuint cmdlen = 16;
4052     (void) dpy;
4053     emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4054     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4055     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4056     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4057     gc->pc += cmdlen;
4058     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4059 }
4060
4061 #define X_GLrop_Viewport 191
4062 void
4063 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
4064 {
4065     __GLXcontext * const gc = __glXGetCurrentContext();
4066     Display * const dpy = gc->currentDpy;
4067     const GLuint cmdlen = 20;
4068     (void) dpy;
4069     emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
4070     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4071     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4072     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
4073     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
4074     gc->pc += cmdlen;
4075     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4076 }
4077
4078 #define X_GLrop_BindTexture 4117
4079 void
4080 __indirect_glBindTexture(GLenum target, GLuint texture)
4081 {
4082     __GLXcontext * const gc = __glXGetCurrentContext();
4083     Display * const dpy = gc->currentDpy;
4084     const GLuint cmdlen = 12;
4085     (void) dpy;
4086     emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
4087     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4088     (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
4089     gc->pc += cmdlen;
4090     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4091 }
4092
4093 #define X_GLrop_Indexubv 194
4094 void
4095 __indirect_glIndexub(GLubyte c)
4096 {
4097     __GLXcontext * const gc = __glXGetCurrentContext();
4098     Display * const dpy = gc->currentDpy;
4099     const GLuint cmdlen = 8;
4100     (void) dpy;
4101     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4102     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
4103     gc->pc += cmdlen;
4104     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4105 }
4106
4107 #define X_GLrop_Indexubv 194
4108 void
4109 __indirect_glIndexubv(const GLubyte * c)
4110 {
4111     __GLXcontext * const gc = __glXGetCurrentContext();
4112     Display * const dpy = gc->currentDpy;
4113     const GLuint cmdlen = 8;
4114     (void) dpy;
4115     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
4116     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
4117     gc->pc += cmdlen;
4118     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4119 }
4120
4121 #define X_GLrop_PolygonOffset 192
4122 void
4123 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
4124 {
4125     __GLXcontext * const gc = __glXGetCurrentContext();
4126     Display * const dpy = gc->currentDpy;
4127     const GLuint cmdlen = 12;
4128     (void) dpy;
4129     emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
4130     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
4131     (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
4132     gc->pc += cmdlen;
4133     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4134 }
4135
4136 #define X_GLsop_AreTexturesResident 143
4137 GLboolean
4138 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
4139 {
4140     __GLXcontext * const gc = __glXGetCurrentContext();
4141     Display * const dpy = gc->currentDpy;
4142     GLboolean retval = (GLboolean) 0;
4143     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4144     if (n < 0) return retval;
4145     (void) dpy;
4146     if (dpy != NULL) {
4147         GLubyte const * pc = setup_single_request(gc, X_GLsop_AreTexturesResident, cmdlen);
4148         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4149         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4150         retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
4151         UnlockDisplay(gc->currentDpy); SyncHandle();
4152     }
4153     return retval;
4154 }
4155
4156 #define X_GLrop_CopyTexImage1D 4119
4157 void
4158 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
4159 {
4160     __GLXcontext * const gc = __glXGetCurrentContext();
4161     Display * const dpy = gc->currentDpy;
4162     const GLuint cmdlen = 32;
4163     (void) dpy;
4164     emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
4165     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4166     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4167     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4168     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4169     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4170     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4171     (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
4172     gc->pc += cmdlen;
4173     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4174 }
4175
4176 #define X_GLrop_CopyTexImage2D 4120
4177 void
4178 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
4179 {
4180     __GLXcontext * const gc = __glXGetCurrentContext();
4181     Display * const dpy = gc->currentDpy;
4182     const GLuint cmdlen = 36;
4183     (void) dpy;
4184     emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
4185     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4186     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4187     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4188     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4189     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4190     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4191     (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
4192     (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
4193     gc->pc += cmdlen;
4194     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4195 }
4196
4197 #define X_GLrop_CopyTexSubImage1D 4121
4198 void
4199 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
4200 {
4201     __GLXcontext * const gc = __glXGetCurrentContext();
4202     Display * const dpy = gc->currentDpy;
4203     const GLuint cmdlen = 28;
4204     (void) dpy;
4205     emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
4206     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4207     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4208     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4209     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
4210     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
4211     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
4212     gc->pc += cmdlen;
4213     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4214 }
4215
4216 #define X_GLrop_CopyTexSubImage2D 4122
4217 void
4218 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4219 {
4220     __GLXcontext * const gc = __glXGetCurrentContext();
4221     Display * const dpy = gc->currentDpy;
4222     const GLuint cmdlen = 36;
4223     (void) dpy;
4224     emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
4225     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4226     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4227     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4228     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4229     (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
4230     (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
4231     (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
4232     (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
4233     gc->pc += cmdlen;
4234     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4235 }
4236
4237 #define X_GLsop_DeleteTextures 144
4238 void
4239 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
4240 {
4241     __GLXcontext * const gc = __glXGetCurrentContext();
4242     Display * const dpy = gc->currentDpy;
4243     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4244     if (n < 0) return;
4245     (void) dpy;
4246     if (dpy != NULL) {
4247         GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteTextures, cmdlen);
4248         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4249         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4250         UnlockDisplay(gc->currentDpy); SyncHandle();
4251     }
4252     return;
4253 }
4254
4255 #define X_GLsop_GenTextures 145
4256 void
4257 __indirect_glGenTextures(GLsizei n, GLuint * textures)
4258 {
4259     __GLXcontext * const gc = __glXGetCurrentContext();
4260     Display * const dpy = gc->currentDpy;
4261     const GLuint cmdlen = 4;
4262     (void) dpy;
4263     if (dpy != NULL) {
4264         GLubyte const * pc = setup_single_request(gc, X_GLsop_GenTextures, cmdlen);
4265         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4266         (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
4267         UnlockDisplay(gc->currentDpy); SyncHandle();
4268     }
4269     return;
4270 }
4271
4272 #define X_GLsop_IsTexture 146
4273 GLboolean
4274 __indirect_glIsTexture(GLuint texture)
4275 {
4276     __GLXcontext * const gc = __glXGetCurrentContext();
4277     Display * const dpy = gc->currentDpy;
4278     GLboolean retval = (GLboolean) 0;
4279     const GLuint cmdlen = 4;
4280     (void) dpy;
4281     if (dpy != NULL) {
4282         GLubyte const * pc = setup_single_request(gc, X_GLsop_IsTexture, cmdlen);
4283         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4284         retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
4285         UnlockDisplay(gc->currentDpy); SyncHandle();
4286     }
4287     return retval;
4288 }
4289
4290 #define X_GLrop_PrioritizeTextures 4118
4291 void
4292 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
4293 {
4294     __GLXcontext * const gc = __glXGetCurrentContext();
4295     Display * const dpy = gc->currentDpy;
4296     const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
4297     if (n < 0) return;
4298     (void) dpy;
4299     emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
4300     (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
4301     (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
4302     (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
4303     gc->pc += cmdlen;
4304     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4305 }
4306
4307 #define X_GLrop_BlendColor 4096
4308 void
4309 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
4310 {
4311     __GLXcontext * const gc = __glXGetCurrentContext();
4312     Display * const dpy = gc->currentDpy;
4313     const GLuint cmdlen = 20;
4314     (void) dpy;
4315     emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
4316     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4317     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4318     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
4319     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
4320     gc->pc += cmdlen;
4321     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4322 }
4323
4324 #define X_GLrop_BlendEquation 4097
4325 void
4326 __indirect_glBlendEquation(GLenum mode)
4327 {
4328     __GLXcontext * const gc = __glXGetCurrentContext();
4329     Display * const dpy = gc->currentDpy;
4330     const GLuint cmdlen = 8;
4331     (void) dpy;
4332     emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
4333     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
4334     gc->pc += cmdlen;
4335     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4336 }
4337
4338 #define X_GLrop_ColorTableParameterfv 2054
4339 void
4340 __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4341 {
4342     __GLXcontext * const gc = __glXGetCurrentContext();
4343     Display * const dpy = gc->currentDpy;
4344     const GLuint compsize = __glColorTableParameterfv_size(pname);
4345     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4346     (void) dpy;
4347     emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
4348     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4349     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4350     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4351     gc->pc += cmdlen;
4352     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4353 }
4354
4355 #define X_GLrop_ColorTableParameteriv 2055
4356 void
4357 __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
4358 {
4359     __GLXcontext * const gc = __glXGetCurrentContext();
4360     Display * const dpy = gc->currentDpy;
4361     const GLuint compsize = __glColorTableParameteriv_size(pname);
4362     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4363     (void) dpy;
4364     emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
4365     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4366     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4367     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4368     gc->pc += cmdlen;
4369     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4370 }
4371
4372 #define X_GLrop_CopyColorTable 2056
4373 void
4374 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4375 {
4376     __GLXcontext * const gc = __glXGetCurrentContext();
4377     Display * const dpy = gc->currentDpy;
4378     const GLuint cmdlen = 24;
4379     (void) dpy;
4380     emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
4381     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4382     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4383     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4384     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4385     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4386     gc->pc += cmdlen;
4387     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4388 }
4389
4390 #define X_GLsop_GetColorTableParameterfv 148
4391 void
4392 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
4393 {
4394     __GLXcontext * const gc = __glXGetCurrentContext();
4395     Display * const dpy = gc->currentDpy;
4396     const GLuint cmdlen = 8;
4397     (void) dpy;
4398     if (dpy != NULL) {
4399         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
4400         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4401         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4402         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4403         UnlockDisplay(gc->currentDpy); SyncHandle();
4404     }
4405     return;
4406 }
4407
4408 #define X_GLsop_GetColorTableParameteriv 149
4409 void
4410 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
4411 {
4412     __GLXcontext * const gc = __glXGetCurrentContext();
4413     Display * const dpy = gc->currentDpy;
4414     const GLuint cmdlen = 8;
4415     (void) dpy;
4416     if (dpy != NULL) {
4417         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
4418         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4419         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4420         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4421         UnlockDisplay(gc->currentDpy); SyncHandle();
4422     }
4423     return;
4424 }
4425
4426 #define X_GLrop_CopyColorSubTable 196
4427 void
4428 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
4429 {
4430     __GLXcontext * const gc = __glXGetCurrentContext();
4431     Display * const dpy = gc->currentDpy;
4432     const GLuint cmdlen = 24;
4433     (void) dpy;
4434     emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
4435     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4436     (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
4437     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4438     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4439     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4440     gc->pc += cmdlen;
4441     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4442 }
4443
4444 #define X_GLrop_ConvolutionParameterf 4103
4445 void
4446 __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
4447 {
4448     __GLXcontext * const gc = __glXGetCurrentContext();
4449     Display * const dpy = gc->currentDpy;
4450     const GLuint cmdlen = 16;
4451     (void) dpy;
4452     emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
4453     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4454     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4455     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4456     gc->pc += cmdlen;
4457     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4458 }
4459
4460 #define X_GLrop_ConvolutionParameterfv 4104
4461 void
4462 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4463 {
4464     __GLXcontext * const gc = __glXGetCurrentContext();
4465     Display * const dpy = gc->currentDpy;
4466     const GLuint compsize = __glConvolutionParameterfv_size(pname);
4467     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4468     (void) dpy;
4469     emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
4470     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4471     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4472     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4473     gc->pc += cmdlen;
4474     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4475 }
4476
4477 #define X_GLrop_ConvolutionParameteri 4105
4478 void
4479 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
4480 {
4481     __GLXcontext * const gc = __glXGetCurrentContext();
4482     Display * const dpy = gc->currentDpy;
4483     const GLuint cmdlen = 16;
4484     (void) dpy;
4485     emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
4486     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4487     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4488     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4489     gc->pc += cmdlen;
4490     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4491 }
4492
4493 #define X_GLrop_ConvolutionParameteriv 4106
4494 void
4495 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
4496 {
4497     __GLXcontext * const gc = __glXGetCurrentContext();
4498     Display * const dpy = gc->currentDpy;
4499     const GLuint compsize = __glConvolutionParameteriv_size(pname);
4500     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4501     (void) dpy;
4502     emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
4503     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4504     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4505     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4506     gc->pc += cmdlen;
4507     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4508 }
4509
4510 #define X_GLrop_CopyConvolutionFilter1D 4107
4511 void
4512 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4513 {
4514     __GLXcontext * const gc = __glXGetCurrentContext();
4515     Display * const dpy = gc->currentDpy;
4516     const GLuint cmdlen = 24;
4517     (void) dpy;
4518     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
4519     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4520     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4521     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4522     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4523     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4524     gc->pc += cmdlen;
4525     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4526 }
4527
4528 #define X_GLrop_CopyConvolutionFilter2D 4108
4529 void
4530 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
4531 {
4532     __GLXcontext * const gc = __glXGetCurrentContext();
4533     Display * const dpy = gc->currentDpy;
4534     const GLuint cmdlen = 28;
4535     (void) dpy;
4536     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
4537     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4538     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4539     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4540     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4541     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4542     (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
4543     gc->pc += cmdlen;
4544     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4545 }
4546
4547 #define X_GLsop_GetConvolutionParameterfv 151
4548 void
4549 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
4550 {
4551     __GLXcontext * const gc = __glXGetCurrentContext();
4552     Display * const dpy = gc->currentDpy;
4553     const GLuint cmdlen = 8;
4554     (void) dpy;
4555     if (dpy != NULL) {
4556         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
4557         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4558         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4559         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4560         UnlockDisplay(gc->currentDpy); SyncHandle();
4561     }
4562     return;
4563 }
4564
4565 #define X_GLsop_GetConvolutionParameteriv 152
4566 void
4567 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
4568 {
4569     __GLXcontext * const gc = __glXGetCurrentContext();
4570     Display * const dpy = gc->currentDpy;
4571     const GLuint cmdlen = 8;
4572     (void) dpy;
4573     if (dpy != NULL) {
4574         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
4575         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4576         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4577         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4578         UnlockDisplay(gc->currentDpy); SyncHandle();
4579     }
4580     return;
4581 }
4582
4583 #define X_GLsop_GetHistogramParameterfv 155
4584 void
4585 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
4586 {
4587     __GLXcontext * const gc = __glXGetCurrentContext();
4588     Display * const dpy = gc->currentDpy;
4589     const GLuint cmdlen = 8;
4590     (void) dpy;
4591     if (dpy != NULL) {
4592         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
4593         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4594         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4595         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4596         UnlockDisplay(gc->currentDpy); SyncHandle();
4597     }
4598     return;
4599 }
4600
4601 #define X_GLsop_GetHistogramParameteriv 156
4602 void
4603 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
4604 {
4605     __GLXcontext * const gc = __glXGetCurrentContext();
4606     Display * const dpy = gc->currentDpy;
4607     const GLuint cmdlen = 8;
4608     (void) dpy;
4609     if (dpy != NULL) {
4610         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
4611         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4612         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4613         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4614         UnlockDisplay(gc->currentDpy); SyncHandle();
4615     }
4616     return;
4617 }
4618
4619 #define X_GLsop_GetMinmaxParameterfv 158
4620 void
4621 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
4622 {
4623     __GLXcontext * const gc = __glXGetCurrentContext();
4624     Display * const dpy = gc->currentDpy;
4625     const GLuint cmdlen = 8;
4626     (void) dpy;
4627     if (dpy != NULL) {
4628         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
4629         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4630         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4631         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4632         UnlockDisplay(gc->currentDpy); SyncHandle();
4633     }
4634     return;
4635 }
4636
4637 #define X_GLsop_GetMinmaxParameteriv 159
4638 void
4639 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
4640 {
4641     __GLXcontext * const gc = __glXGetCurrentContext();
4642     Display * const dpy = gc->currentDpy;
4643     const GLuint cmdlen = 8;
4644     (void) dpy;
4645     if (dpy != NULL) {
4646         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
4647         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4648         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4649         (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
4650         UnlockDisplay(gc->currentDpy); SyncHandle();
4651     }
4652     return;
4653 }
4654
4655 #define X_GLrop_Histogram 4110
4656 void
4657 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
4658 {
4659     __GLXcontext * const gc = __glXGetCurrentContext();
4660     Display * const dpy = gc->currentDpy;
4661     const GLuint cmdlen = 20;
4662     (void) dpy;
4663     emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
4664     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4665     (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
4666     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4667     (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
4668     gc->pc += cmdlen;
4669     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4670 }
4671
4672 #define X_GLrop_Minmax 4111
4673 void
4674 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
4675 {
4676     __GLXcontext * const gc = __glXGetCurrentContext();
4677     Display * const dpy = gc->currentDpy;
4678     const GLuint cmdlen = 16;
4679     (void) dpy;
4680     emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
4681     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4682     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4683     (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
4684     gc->pc += cmdlen;
4685     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4686 }
4687
4688 #define X_GLrop_ResetHistogram 4112
4689 void
4690 __indirect_glResetHistogram(GLenum target)
4691 {
4692     __GLXcontext * const gc = __glXGetCurrentContext();
4693     Display * const dpy = gc->currentDpy;
4694     const GLuint cmdlen = 8;
4695     (void) dpy;
4696     emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
4697     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4698     gc->pc += cmdlen;
4699     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4700 }
4701
4702 #define X_GLrop_ResetMinmax 4113
4703 void
4704 __indirect_glResetMinmax(GLenum target)
4705 {
4706     __GLXcontext * const gc = __glXGetCurrentContext();
4707     Display * const dpy = gc->currentDpy;
4708     const GLuint cmdlen = 8;
4709     (void) dpy;
4710     emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
4711     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4712     gc->pc += cmdlen;
4713     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4714 }
4715
4716 #define X_GLrop_CopyTexSubImage3D 4123
4717 void
4718 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4719 {
4720     __GLXcontext * const gc = __glXGetCurrentContext();
4721     Display * const dpy = gc->currentDpy;
4722     const GLuint cmdlen = 40;
4723     (void) dpy;
4724     emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
4725     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4726     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4727     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4728     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4729     (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
4730     (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
4731     (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
4732     (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4733     (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4734     gc->pc += cmdlen;
4735     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4736 }
4737
4738 #define X_GLrop_ActiveTextureARB 197
4739 void
4740 __indirect_glActiveTextureARB(GLenum texture)
4741 {
4742     __GLXcontext * const gc = __glXGetCurrentContext();
4743     Display * const dpy = gc->currentDpy;
4744     const GLuint cmdlen = 8;
4745     (void) dpy;
4746     emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
4747     (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
4748     gc->pc += cmdlen;
4749     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4750 }
4751
4752 #define X_GLrop_MultiTexCoord1dvARB 198
4753 void
4754 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
4755 {
4756     __GLXcontext * const gc = __glXGetCurrentContext();
4757     Display * const dpy = gc->currentDpy;
4758     const GLuint cmdlen = 16;
4759     (void) dpy;
4760     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4761     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4762     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4763     gc->pc += cmdlen;
4764     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4765 }
4766
4767 #define X_GLrop_MultiTexCoord1dvARB 198
4768 void
4769 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
4770 {
4771     __GLXcontext * const gc = __glXGetCurrentContext();
4772     Display * const dpy = gc->currentDpy;
4773     const GLuint cmdlen = 16;
4774     (void) dpy;
4775     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4776     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
4777     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4778     gc->pc += cmdlen;
4779     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4780 }
4781
4782 #define X_GLrop_MultiTexCoord1fvARB 199
4783 void
4784 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
4785 {
4786     __GLXcontext * const gc = __glXGetCurrentContext();
4787     Display * const dpy = gc->currentDpy;
4788     const GLuint cmdlen = 12;
4789     (void) dpy;
4790     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4791     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4792     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4793     gc->pc += cmdlen;
4794     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4795 }
4796
4797 #define X_GLrop_MultiTexCoord1fvARB 199
4798 void
4799 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
4800 {
4801     __GLXcontext * const gc = __glXGetCurrentContext();
4802     Display * const dpy = gc->currentDpy;
4803     const GLuint cmdlen = 12;
4804     (void) dpy;
4805     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4806     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4807     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4808     gc->pc += cmdlen;
4809     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4810 }
4811
4812 #define X_GLrop_MultiTexCoord1ivARB 200
4813 void
4814 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
4815 {
4816     __GLXcontext * const gc = __glXGetCurrentContext();
4817     Display * const dpy = gc->currentDpy;
4818     const GLuint cmdlen = 12;
4819     (void) dpy;
4820     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4821     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4822     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4823     gc->pc += cmdlen;
4824     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4825 }
4826
4827 #define X_GLrop_MultiTexCoord1ivARB 200
4828 void
4829 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
4830 {
4831     __GLXcontext * const gc = __glXGetCurrentContext();
4832     Display * const dpy = gc->currentDpy;
4833     const GLuint cmdlen = 12;
4834     (void) dpy;
4835     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4836     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4837     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4838     gc->pc += cmdlen;
4839     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4840 }
4841
4842 #define X_GLrop_MultiTexCoord1svARB 201
4843 void
4844 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
4845 {
4846     __GLXcontext * const gc = __glXGetCurrentContext();
4847     Display * const dpy = gc->currentDpy;
4848     const GLuint cmdlen = 12;
4849     (void) dpy;
4850     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4851     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4852     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4853     gc->pc += cmdlen;
4854     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4855 }
4856
4857 #define X_GLrop_MultiTexCoord1svARB 201
4858 void
4859 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
4860 {
4861     __GLXcontext * const gc = __glXGetCurrentContext();
4862     Display * const dpy = gc->currentDpy;
4863     const GLuint cmdlen = 12;
4864     (void) dpy;
4865     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4866     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4867     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
4868     gc->pc += cmdlen;
4869     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4870 }
4871
4872 #define X_GLrop_MultiTexCoord2dvARB 202
4873 void
4874 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
4875 {
4876     __GLXcontext * const gc = __glXGetCurrentContext();
4877     Display * const dpy = gc->currentDpy;
4878     const GLuint cmdlen = 24;
4879     (void) dpy;
4880     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4881     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4882     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
4883     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4884     gc->pc += cmdlen;
4885     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4886 }
4887
4888 #define X_GLrop_MultiTexCoord2dvARB 202
4889 void
4890 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
4891 {
4892     __GLXcontext * const gc = __glXGetCurrentContext();
4893     Display * const dpy = gc->currentDpy;
4894     const GLuint cmdlen = 24;
4895     (void) dpy;
4896     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4897     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
4898     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4899     gc->pc += cmdlen;
4900     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4901 }
4902
4903 #define X_GLrop_MultiTexCoord2fvARB 203
4904 void
4905 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
4906 {
4907     __GLXcontext * const gc = __glXGetCurrentContext();
4908     Display * const dpy = gc->currentDpy;
4909     const GLuint cmdlen = 16;
4910     (void) dpy;
4911     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4912     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4913     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4914     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4915     gc->pc += cmdlen;
4916     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4917 }
4918
4919 #define X_GLrop_MultiTexCoord2fvARB 203
4920 void
4921 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
4922 {
4923     __GLXcontext * const gc = __glXGetCurrentContext();
4924     Display * const dpy = gc->currentDpy;
4925     const GLuint cmdlen = 16;
4926     (void) dpy;
4927     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4928     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4929     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4930     gc->pc += cmdlen;
4931     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4932 }
4933
4934 #define X_GLrop_MultiTexCoord2ivARB 204
4935 void
4936 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
4937 {
4938     __GLXcontext * const gc = __glXGetCurrentContext();
4939     Display * const dpy = gc->currentDpy;
4940     const GLuint cmdlen = 16;
4941     (void) dpy;
4942     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4943     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4944     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4945     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4946     gc->pc += cmdlen;
4947     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4948 }
4949
4950 #define X_GLrop_MultiTexCoord2ivARB 204
4951 void
4952 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
4953 {
4954     __GLXcontext * const gc = __glXGetCurrentContext();
4955     Display * const dpy = gc->currentDpy;
4956     const GLuint cmdlen = 16;
4957     (void) dpy;
4958     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4959     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4960     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4961     gc->pc += cmdlen;
4962     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4963 }
4964
4965 #define X_GLrop_MultiTexCoord2svARB 205
4966 void
4967 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
4968 {
4969     __GLXcontext * const gc = __glXGetCurrentContext();
4970     Display * const dpy = gc->currentDpy;
4971     const GLuint cmdlen = 12;
4972     (void) dpy;
4973     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4974     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4975     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4976     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
4977     gc->pc += cmdlen;
4978     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4979 }
4980
4981 #define X_GLrop_MultiTexCoord2svARB 205
4982 void
4983 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
4984 {
4985     __GLXcontext * const gc = __glXGetCurrentContext();
4986     Display * const dpy = gc->currentDpy;
4987     const GLuint cmdlen = 12;
4988     (void) dpy;
4989     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4990     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4991     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4992     gc->pc += cmdlen;
4993     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4994 }
4995
4996 #define X_GLrop_MultiTexCoord3dvARB 206
4997 void
4998 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
4999 {
5000     __GLXcontext * const gc = __glXGetCurrentContext();
5001     Display * const dpy = gc->currentDpy;
5002     const GLuint cmdlen = 32;
5003     (void) dpy;
5004     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5005     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5006     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5007     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5008     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5009     gc->pc += cmdlen;
5010     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5011 }
5012
5013 #define X_GLrop_MultiTexCoord3dvARB 206
5014 void
5015 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
5016 {
5017     __GLXcontext * const gc = __glXGetCurrentContext();
5018     Display * const dpy = gc->currentDpy;
5019     const GLuint cmdlen = 32;
5020     (void) dpy;
5021     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
5022     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
5023     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
5024     gc->pc += cmdlen;
5025     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5026 }
5027
5028 #define X_GLrop_MultiTexCoord3fvARB 207
5029 void
5030 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
5031 {
5032     __GLXcontext * const gc = __glXGetCurrentContext();
5033     Display * const dpy = gc->currentDpy;
5034     const GLuint cmdlen = 20;
5035     (void) dpy;
5036     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5037     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5038     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5039     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5040     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5041     gc->pc += cmdlen;
5042     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5043 }
5044
5045 #define X_GLrop_MultiTexCoord3fvARB 207
5046 void
5047 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
5048 {
5049     __GLXcontext * const gc = __glXGetCurrentContext();
5050     Display * const dpy = gc->currentDpy;
5051     const GLuint cmdlen = 20;
5052     (void) dpy;
5053     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
5054     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5055     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5056     gc->pc += cmdlen;
5057     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5058 }
5059
5060 #define X_GLrop_MultiTexCoord3ivARB 208
5061 void
5062 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
5063 {
5064     __GLXcontext * const gc = __glXGetCurrentContext();
5065     Display * const dpy = gc->currentDpy;
5066     const GLuint cmdlen = 20;
5067     (void) dpy;
5068     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5069     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5070     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5071     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5072     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5073     gc->pc += cmdlen;
5074     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5075 }
5076
5077 #define X_GLrop_MultiTexCoord3ivARB 208
5078 void
5079 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
5080 {
5081     __GLXcontext * const gc = __glXGetCurrentContext();
5082     Display * const dpy = gc->currentDpy;
5083     const GLuint cmdlen = 20;
5084     (void) dpy;
5085     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
5086     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5087     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
5088     gc->pc += cmdlen;
5089     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5090 }
5091
5092 #define X_GLrop_MultiTexCoord3svARB 209
5093 void
5094 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
5095 {
5096     __GLXcontext * const gc = __glXGetCurrentContext();
5097     Display * const dpy = gc->currentDpy;
5098     const GLuint cmdlen = 16;
5099     (void) dpy;
5100     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5101     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5102     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5103     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5104     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5105     gc->pc += cmdlen;
5106     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5107 }
5108
5109 #define X_GLrop_MultiTexCoord3svARB 209
5110 void
5111 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
5112 {
5113     __GLXcontext * const gc = __glXGetCurrentContext();
5114     Display * const dpy = gc->currentDpy;
5115     const GLuint cmdlen = 16;
5116     (void) dpy;
5117     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
5118     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5119     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
5120     gc->pc += cmdlen;
5121     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5122 }
5123
5124 #define X_GLrop_MultiTexCoord4dvARB 210
5125 void
5126 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
5127 {
5128     __GLXcontext * const gc = __glXGetCurrentContext();
5129     Display * const dpy = gc->currentDpy;
5130     const GLuint cmdlen = 40;
5131     (void) dpy;
5132     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5133     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
5134     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
5135     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
5136     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
5137     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5138     gc->pc += cmdlen;
5139     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5140 }
5141
5142 #define X_GLrop_MultiTexCoord4dvARB 210
5143 void
5144 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
5145 {
5146     __GLXcontext * const gc = __glXGetCurrentContext();
5147     Display * const dpy = gc->currentDpy;
5148     const GLuint cmdlen = 40;
5149     (void) dpy;
5150     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
5151     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
5152     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
5153     gc->pc += cmdlen;
5154     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5155 }
5156
5157 #define X_GLrop_MultiTexCoord4fvARB 211
5158 void
5159 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
5160 {
5161     __GLXcontext * const gc = __glXGetCurrentContext();
5162     Display * const dpy = gc->currentDpy;
5163     const GLuint cmdlen = 24;
5164     (void) dpy;
5165     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5166     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5167     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5168     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5169     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5170     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5171     gc->pc += cmdlen;
5172     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5173 }
5174
5175 #define X_GLrop_MultiTexCoord4fvARB 211
5176 void
5177 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
5178 {
5179     __GLXcontext * const gc = __glXGetCurrentContext();
5180     Display * const dpy = gc->currentDpy;
5181     const GLuint cmdlen = 24;
5182     (void) dpy;
5183     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
5184     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5185     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5186     gc->pc += cmdlen;
5187     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5188 }
5189
5190 #define X_GLrop_MultiTexCoord4ivARB 212
5191 void
5192 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
5193 {
5194     __GLXcontext * const gc = __glXGetCurrentContext();
5195     Display * const dpy = gc->currentDpy;
5196     const GLuint cmdlen = 24;
5197     (void) dpy;
5198     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5199     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5200     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
5201     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
5202     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
5203     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
5204     gc->pc += cmdlen;
5205     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5206 }
5207
5208 #define X_GLrop_MultiTexCoord4ivARB 212
5209 void
5210 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
5211 {
5212     __GLXcontext * const gc = __glXGetCurrentContext();
5213     Display * const dpy = gc->currentDpy;
5214     const GLuint cmdlen = 24;
5215     (void) dpy;
5216     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
5217     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5218     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
5219     gc->pc += cmdlen;
5220     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5221 }
5222
5223 #define X_GLrop_MultiTexCoord4svARB 213
5224 void
5225 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
5226 {
5227     __GLXcontext * const gc = __glXGetCurrentContext();
5228     Display * const dpy = gc->currentDpy;
5229     const GLuint cmdlen = 16;
5230     (void) dpy;
5231     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5232     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5233     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
5234     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
5235     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
5236     (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
5237     gc->pc += cmdlen;
5238     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5239 }
5240
5241 #define X_GLrop_MultiTexCoord4svARB 213
5242 void
5243 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
5244 {
5245     __GLXcontext * const gc = __glXGetCurrentContext();
5246     Display * const dpy = gc->currentDpy;
5247     const GLuint cmdlen = 16;
5248     (void) dpy;
5249     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
5250     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
5251     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
5252     gc->pc += cmdlen;
5253     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5254 }
5255
5256 #define X_GLrop_SampleCoverageARB 229
5257 void
5258 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
5259 {
5260     __GLXcontext * const gc = __glXGetCurrentContext();
5261     Display * const dpy = gc->currentDpy;
5262     const GLuint cmdlen = 12;
5263     (void) dpy;
5264     emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
5265     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5266     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5267     gc->pc += cmdlen;
5268     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5269 }
5270
5271 #define X_GLvop_AreTexturesResidentEXT 11
5272 GLboolean
5273 __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
5274 {
5275     __GLXcontext * const gc = __glXGetCurrentContext();
5276     Display * const dpy = gc->currentDpy;
5277     GLboolean retval = (GLboolean) 0;
5278     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5279     if (n < 0) return retval;
5280     (void) dpy;
5281     if (dpy != NULL) {
5282         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
5283         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5284         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
5285         retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
5286         UnlockDisplay(gc->currentDpy); SyncHandle();
5287     }
5288     return retval;
5289 }
5290
5291 #define X_GLvop_GenTexturesEXT 13
5292 void
5293 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
5294 {
5295     __GLXcontext * const gc = __glXGetCurrentContext();
5296     Display * const dpy = gc->currentDpy;
5297     const GLuint cmdlen = 4;
5298     (void) dpy;
5299     if (dpy != NULL) {
5300         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
5301         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
5302         (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
5303         UnlockDisplay(gc->currentDpy); SyncHandle();
5304     }
5305     return;
5306 }
5307
5308 #define X_GLvop_IsTextureEXT 14
5309 GLboolean
5310 __indirect_glIsTextureEXT(GLuint texture)
5311 {
5312     __GLXcontext * const gc = __glXGetCurrentContext();
5313     Display * const dpy = gc->currentDpy;
5314     GLboolean retval = (GLboolean) 0;
5315     const GLuint cmdlen = 4;
5316     (void) dpy;
5317     if (dpy != NULL) {
5318         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
5319         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
5320         retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
5321         UnlockDisplay(gc->currentDpy); SyncHandle();
5322     }
5323     return retval;
5324 }
5325
5326 #define X_GLrop_SampleMaskSGIS 2048
5327 void
5328 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
5329 {
5330     __GLXcontext * const gc = __glXGetCurrentContext();
5331     Display * const dpy = gc->currentDpy;
5332     const GLuint cmdlen = 12;
5333     (void) dpy;
5334     emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
5335     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
5336     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
5337     gc->pc += cmdlen;
5338     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5339 }
5340
5341 #define X_GLrop_SamplePatternSGIS 2049
5342 void
5343 __indirect_glSamplePatternSGIS(GLenum pattern)
5344 {
5345     __GLXcontext * const gc = __glXGetCurrentContext();
5346     Display * const dpy = gc->currentDpy;
5347     const GLuint cmdlen = 8;
5348     (void) dpy;
5349     emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
5350     (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
5351     gc->pc += cmdlen;
5352     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5353 }
5354
5355 #define X_GLrop_PointParameterfEXT 2065
5356 void
5357 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
5358 {
5359     __GLXcontext * const gc = __glXGetCurrentContext();
5360     Display * const dpy = gc->currentDpy;
5361     const GLuint cmdlen = 12;
5362     (void) dpy;
5363     emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
5364     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5365     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
5366     gc->pc += cmdlen;
5367     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5368 }
5369
5370 #define X_GLrop_PointParameterfvEXT 2066
5371 void
5372 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
5373 {
5374     __GLXcontext * const gc = __glXGetCurrentContext();
5375     Display * const dpy = gc->currentDpy;
5376     const GLuint compsize = __glPointParameterfvEXT_size(pname);
5377     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5378     (void) dpy;
5379     emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
5380     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5381     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5382     gc->pc += cmdlen;
5383     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5384 }
5385
5386 #define X_GLrop_WindowPos3fvMESA 230
5387 void
5388 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
5389 {
5390     __GLXcontext * const gc = __glXGetCurrentContext();
5391     Display * const dpy = gc->currentDpy;
5392     const GLuint cmdlen = 16;
5393     (void) dpy;
5394     emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
5395     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
5396     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
5397     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
5398     gc->pc += cmdlen;
5399     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5400 }
5401
5402 #define X_GLrop_WindowPos3fvMESA 230
5403 void
5404 __indirect_glWindowPos3fvMESA(const GLfloat * v)
5405 {
5406     generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
5407 }
5408
5409 #define X_GLrop_BlendFuncSeparateEXT 4134
5410 void
5411 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
5412 {
5413     __GLXcontext * const gc = __glXGetCurrentContext();
5414     Display * const dpy = gc->currentDpy;
5415     const GLuint cmdlen = 20;
5416     (void) dpy;
5417     emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
5418     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
5419     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
5420     (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
5421     (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
5422     gc->pc += cmdlen;
5423     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5424 }
5425
5426 #define X_GLrop_FogCoordfvEXT 4124
5427 void
5428 __indirect_glFogCoordfEXT(GLfloat coord)
5429 {
5430     __GLXcontext * const gc = __glXGetCurrentContext();
5431     Display * const dpy = gc->currentDpy;
5432     const GLuint cmdlen = 8;
5433     (void) dpy;
5434     emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
5435     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
5436     gc->pc += cmdlen;
5437     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5438 }
5439
5440 #define X_GLrop_FogCoordfvEXT 4124
5441 void
5442 __indirect_glFogCoordfvEXT(const GLfloat * coord)
5443 {
5444     generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
5445 }
5446
5447 #define X_GLrop_FogCoorddvEXT 4125
5448 void
5449 __indirect_glFogCoorddEXT(GLdouble coord)
5450 {
5451     __GLXcontext * const gc = __glXGetCurrentContext();
5452     Display * const dpy = gc->currentDpy;
5453     const GLuint cmdlen = 12;
5454     (void) dpy;
5455     emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
5456     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
5457     gc->pc += cmdlen;
5458     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5459 }
5460
5461 #define X_GLrop_FogCoorddvEXT 4125
5462 void
5463 __indirect_glFogCoorddvEXT(const GLdouble * coord)
5464 {
5465     generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
5466 }
5467
5468 #define X_GLrop_SecondaryColor3bvEXT 4126
5469 void
5470 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
5471 {
5472     __GLXcontext * const gc = __glXGetCurrentContext();
5473     Display * const dpy = gc->currentDpy;
5474     const GLuint cmdlen = 8;
5475     (void) dpy;
5476     emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
5477     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5478     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5479     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5480     gc->pc += cmdlen;
5481     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5482 }
5483
5484 #define X_GLrop_SecondaryColor3bvEXT 4126
5485 void
5486 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
5487 {
5488     generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
5489 }
5490
5491 #define X_GLrop_SecondaryColor3dvEXT 4130
5492 void
5493 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
5494 {
5495     __GLXcontext * const gc = __glXGetCurrentContext();
5496     Display * const dpy = gc->currentDpy;
5497     const GLuint cmdlen = 28;
5498     (void) dpy;
5499     emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
5500     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
5501     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
5502     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
5503     gc->pc += cmdlen;
5504     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5505 }
5506
5507 #define X_GLrop_SecondaryColor3dvEXT 4130
5508 void
5509 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
5510 {
5511     generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
5512 }
5513
5514 #define X_GLrop_SecondaryColor3fvEXT 4129
5515 void
5516 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
5517 {
5518     __GLXcontext * const gc = __glXGetCurrentContext();
5519     Display * const dpy = gc->currentDpy;
5520     const GLuint cmdlen = 16;
5521     (void) dpy;
5522     emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
5523     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5524     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5525     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5526     gc->pc += cmdlen;
5527     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5528 }
5529
5530 #define X_GLrop_SecondaryColor3fvEXT 4129
5531 void
5532 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
5533 {
5534     generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
5535 }
5536
5537 #define X_GLrop_SecondaryColor3ivEXT 4128
5538 void
5539 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
5540 {
5541     __GLXcontext * const gc = __glXGetCurrentContext();
5542     Display * const dpy = gc->currentDpy;
5543     const GLuint cmdlen = 16;
5544     (void) dpy;
5545     emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
5546     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5547     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5548     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5549     gc->pc += cmdlen;
5550     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5551 }
5552
5553 #define X_GLrop_SecondaryColor3ivEXT 4128
5554 void
5555 __indirect_glSecondaryColor3ivEXT(const GLint * v)
5556 {
5557     generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
5558 }
5559
5560 #define X_GLrop_SecondaryColor3svEXT 4128
5561 void
5562 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
5563 {
5564     __GLXcontext * const gc = __glXGetCurrentContext();
5565     Display * const dpy = gc->currentDpy;
5566     const GLuint cmdlen = 12;
5567     (void) dpy;
5568     emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
5569     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5570     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5571     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5572     gc->pc += cmdlen;
5573     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5574 }
5575
5576 #define X_GLrop_SecondaryColor3svEXT 4128
5577 void
5578 __indirect_glSecondaryColor3svEXT(const GLshort * v)
5579 {
5580     generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
5581 }
5582
5583 #define X_GLrop_SecondaryColor3ubvEXT 4131
5584 void
5585 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
5586 {
5587     __GLXcontext * const gc = __glXGetCurrentContext();
5588     Display * const dpy = gc->currentDpy;
5589     const GLuint cmdlen = 8;
5590     (void) dpy;
5591     emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
5592     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5593     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5594     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5595     gc->pc += cmdlen;
5596     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5597 }
5598
5599 #define X_GLrop_SecondaryColor3ubvEXT 4131
5600 void
5601 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
5602 {
5603     generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
5604 }
5605
5606 #define X_GLrop_SecondaryColor3uivEXT 4133
5607 void
5608 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
5609 {
5610     __GLXcontext * const gc = __glXGetCurrentContext();
5611     Display * const dpy = gc->currentDpy;
5612     const GLuint cmdlen = 16;
5613     (void) dpy;
5614     emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
5615     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5616     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5617     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5618     gc->pc += cmdlen;
5619     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5620 }
5621
5622 #define X_GLrop_SecondaryColor3uivEXT 4133
5623 void
5624 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
5625 {
5626     generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
5627 }
5628
5629 #define X_GLrop_SecondaryColor3usvEXT 4132
5630 void
5631 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
5632 {
5633     __GLXcontext * const gc = __glXGetCurrentContext();
5634     Display * const dpy = gc->currentDpy;
5635     const GLuint cmdlen = 12;
5636     (void) dpy;
5637     emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
5638     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5639     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5640     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5641     gc->pc += cmdlen;
5642     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5643 }
5644
5645 #define X_GLrop_SecondaryColor3usvEXT 4132
5646 void
5647 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
5648 {
5649     generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
5650 }
5651
5652 #define X_GLrop_PointParameteriNV 4221
5653 void
5654 __indirect_glPointParameteriNV(GLenum pname, GLint params)
5655 {
5656     __GLXcontext * const gc = __glXGetCurrentContext();
5657     Display * const dpy = gc->currentDpy;
5658     const GLuint cmdlen = 12;
5659     (void) dpy;
5660     emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
5661     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5662     (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
5663     gc->pc += cmdlen;
5664     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5665 }
5666
5667 #define X_GLrop_PointParameterivNV 4222
5668 void
5669 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
5670 {
5671     __GLXcontext * const gc = __glXGetCurrentContext();
5672     Display * const dpy = gc->currentDpy;
5673     const GLuint compsize = __glPointParameterivNV_size(pname);
5674     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5675     (void) dpy;
5676     emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
5677     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5678     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5679     gc->pc += cmdlen;
5680     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5681 }
5682
5683 #define X_GLrop_ActiveStencilFaceEXT 4220
5684 void
5685 __indirect_glActiveStencilFaceEXT(GLenum face)
5686 {
5687     __GLXcontext * const gc = __glXGetCurrentContext();
5688     Display * const dpy = gc->currentDpy;
5689     const GLuint cmdlen = 8;
5690     (void) dpy;
5691     emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
5692     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
5693     gc->pc += cmdlen;
5694     if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5695 }
5696